diff --git a/.gitignore b/.gitignore index a10b16d8..85c9a36d 100644 --- a/.gitignore +++ b/.gitignore @@ -157,6 +157,7 @@ cython_debug/ # Project specific *.local .local-observe/ +src/iac_code/pipeline/engine/architecture_rules.json.backup-* # Docs /docs/ @@ -172,4 +173,4 @@ cython_debug/ # Super Powers .superpowers/ .worktrees/ -.agents/ \ No newline at end of file +.agents/ diff --git a/scripts/README.md b/scripts/README.md index 2217ca32..cca53a3a 100644 --- a/scripts/README.md +++ b/scripts/README.md @@ -19,6 +19,7 @@ repository root with `uv run python ...` unless a script-specific README says ot | `observability/local_observe/` | Local observe server implementation and static web UI. | | `observability/local_observe.md` | Manual usage notes for the local observe tool. | | `rendering/test_diagram_render.py` | Manual diagram rendering check. | +| `rendering/preview_template_architecture_llm.py` | Manual ROS template architecture preview with a real LLM semantic pass. | | `repl/e2e/` | Real PTY-driven REPL pipeline end-to-end scenario runner. POSIX-only because it uses `pexpect`. | ## Common Commands @@ -31,6 +32,7 @@ uv run python scripts/a2a/selling_console.py --port 41980 \ --default-cwd "$PWD" uv run python scripts/a2a/e2e/run_recovery_scenarios.py --help uv run python scripts/observability/local_observe.py --help +uv run python scripts/rendering/preview_template_architecture_llm.py --help uv run python scripts/repl/e2e/run_pipeline_scenarios.py --help ``` diff --git a/scripts/rendering/analyze_ros_resource_architecture_rules.py b/scripts/rendering/analyze_ros_resource_architecture_rules.py new file mode 100644 index 00000000..bf5e6f49 --- /dev/null +++ b/scripts/rendering/analyze_ros_resource_architecture_rules.py @@ -0,0 +1,153 @@ +#!/usr/bin/env python3 +"""Collect ROS resource types and generate architecture rule candidate reports.""" + +from __future__ import annotations + +import argparse +import asyncio +import json +import sys +from pathlib import Path +from typing import Any + +from rich.console import Console + +from iac_code.config import get_config_dir +from iac_code.pipeline.engine.architecture_meta import ArchitectureMetaRepository +from iac_code.pipeline.engine.architecture_resource_inventory import ( + ResourceInventorySnapshot, + collect_ros_resource_inventory, +) +from iac_code.pipeline.engine.architecture_rule_candidates import ( + ResourceTypeDecision, + RuleCandidate, + build_resource_type_decisions, + extract_rule_candidates, +) +from iac_code.pipeline.engine.architecture_rule_facts import ( + build_resource_rule_facts, + render_resource_rule_facts_markdown, +) + + +def default_output_dir() -> Path: + return get_config_dir() / "architecture" + + +def default_cache_path() -> Path: + return default_output_dir() / "ros-resource-types.json" + + +def snapshot_summary(snapshot: ResourceInventorySnapshot) -> dict[str, Any]: + return { + "api_resource_types": len(snapshot.api_resource_types), + "local_resource_types": len(snapshot.local_resource_types), + "api_only_resource_types": len(snapshot.api_only_resource_types), + "local_only_resource_types": len(snapshot.local_only_resource_types), + "fetch_errors": len(snapshot.fetch_errors), + "fetched_at": snapshot.fetched_at, + } + + +def write_analysis_outputs( + *, + snapshot: ResourceInventorySnapshot, + candidates: list[RuleCandidate], + decisions: dict[str, ResourceTypeDecision], + json_out: Path, + markdown_out: Path, +) -> None: + json_out.parent.mkdir(parents=True, exist_ok=True) + markdown_out.parent.mkdir(parents=True, exist_ok=True) + + bundle = build_resource_rule_facts(snapshot) + payload = { + "summary": { + **snapshot_summary(snapshot), + **bundle.to_dict()["summary"], + }, + "api_only_resource_types": list(snapshot.api_only_resource_types), + "local_only_resource_types": list(snapshot.local_only_resource_types), + "fetch_errors": snapshot.fetch_errors, + "resource_facts": [fact.to_dict() for fact in bundle.resource_facts], + "rule_signals": [signal.to_dict() for signal in bundle.rule_signals], + } + json_out.write_text(json.dumps(payload, ensure_ascii=False, indent=2, sort_keys=True), encoding="utf-8") + markdown_out.write_text( + render_resource_rule_facts_markdown(bundle), + encoding="utf-8", + ) + + +def parse_args(argv: list[str]) -> argparse.Namespace: + parser = argparse.ArgumentParser( + description="Analyze all ROS resource types and produce architecture rule candidate reports." + ) + parser.add_argument( + "--cache", + type=Path, + default=None, + help="Resource type detail cache path. Defaults to ~/.iac-code/architecture/ros-resource-types.json.", + ) + parser.add_argument("--refresh", action="store_true", help="Refresh cached GetResourceType details.") + parser.add_argument( + "--max-concurrency", + type=int, + default=8, + help="Maximum concurrent GetResourceType calls. Default: 8.", + ) + parser.add_argument( + "--json-out", + type=Path, + default=None, + help="JSON report output path. Defaults to ~/.iac-code/architecture/ros-resource-facts.json.", + ) + parser.add_argument( + "--markdown-out", + type=Path, + default=None, + help="Markdown report output path. Defaults to ~/.iac-code/architecture/ros-resource-facts.md.", + ) + return parser.parse_args(argv) + + +async def async_main(argv: list[str]) -> int: + args = parse_args(argv) + console = Console() + output_dir = default_output_dir() + cache_path = args.cache or default_cache_path() + json_out = args.json_out or output_dir / "ros-resource-facts.json" + markdown_out = args.markdown_out or output_dir / "ros-resource-facts.md" + + console.print("[dim]Collecting ROS resource type inventory...[/]") + snapshot = await collect_ros_resource_inventory( + cache_path=cache_path, + meta_repository=ArchitectureMetaRepository.load_default(), + refresh=args.refresh, + max_concurrency=args.max_concurrency, + ) + candidates = extract_rule_candidates(snapshot) + decisions = build_resource_type_decisions(snapshot, candidates) + write_analysis_outputs( + snapshot=snapshot, + candidates=candidates, + decisions=decisions, + json_out=json_out, + markdown_out=markdown_out, + ) + + summary = snapshot_summary(snapshot) + console.print("[bold]Summary[/]") + console.print_json(json.dumps(summary, ensure_ascii=False)) + console.print(f"[green]Wrote JSON report:[/] {json_out}") + console.print(f"[green]Wrote Markdown report:[/] {markdown_out}") + console.print(f"[dim]Cache:[/] {cache_path}") + return 0 + + +def main() -> None: + raise SystemExit(asyncio.run(async_main(sys.argv[1:]))) + + +if __name__ == "__main__": + main() diff --git a/scripts/rendering/generate_ros_architecture_draft_rules.py b/scripts/rendering/generate_ros_architecture_draft_rules.py new file mode 100644 index 00000000..07fa2110 --- /dev/null +++ b/scripts/rendering/generate_ros_architecture_draft_rules.py @@ -0,0 +1,856 @@ +#!/usr/bin/env python3 +"""Generate LLM draft architecture rules from ROS resource facts.""" + +from __future__ import annotations + +import argparse +import asyncio +import hashlib +import inspect +import json +import sys +from pathlib import Path +from typing import Any, Awaitable, Callable, cast + +from rich.console import Console + +from iac_code.config import DEFAULT_MODEL, get_config_dir, load_credentials, load_saved_model +from iac_code.pipeline.engine.architecture_rule_drafts import ( + apply_reviewed_draft_patches, + parse_draft_rules_response, + render_draft_review_report_markdown, + review_valid_draft_rules, + validate_draft_rules, +) +from iac_code.pipeline.engine.architecture_rule_facts import ResourceRuleFact, ResourceRuleFactsBundle, RuleSignal +from iac_code.providers.base import Message +from iac_code.providers.manager import ProviderManager + +SYSTEM_PROMPT = """\ +You analyze Alibaba Cloud ROS resource type facts and propose architecture diagram rules. +Return ONLY valid JSON, no markdown. + +Schema: +{"draft_rules":[{"resource_type":string,"classification":"core_node|container|attachment|bridge_attachment|attachment_edge|orchestration_action|concept_node|supplemental_relation|display|ignore|needs_review","target_resource_types":[string],"property_names":[string],"label":string|object|null,"edge_label":string|object|null,"confidence":number,"evidence":[string],"suggested_architecture_rules_patch":object}]} + +Rules: +- Use only resource_type and property names present in the input facts. +- Treat rule_signals as hints, not final decisions. +- Configuration, binding, rule, entry, whitelist, command, and invocation resources should usually be attachments, + bridge attachments, attachment edges, or orchestration actions, not core visible nodes. +- Output ONLY actionable draft rules that should change architecture_rules.json. Omit resources that should stay + core_node, ignore, or needs_review. An empty {"draft_rules": []} is valid for a chunk with no fixed-rule changes. +- Do not use solid business traffic edges for attachment/configuration relationships. +- For every actionable draft, suggested_architecture_rules_patch is REQUIRED and must use one of these shapes: + attachment -> + {"compact_child_attachments":[{"resource_types":[...],"target_properties":[...],"target_types":[...],"label":...}]} + bridge_attachment -> + {"compact_bridge_attachments":[{"resource_types":[...],"source_properties":[...], + "via_resource_types":[...],"via_source_properties":[...],"via_target_properties":[...], + "target_types":[...],"label":...}]} + attachment_edge -> + {"compact_attachment_edges":[{"resource_types":[...],"source_properties":[...], + "marker_properties":[...],"source_types":[...],"marker_types":[...], + "edge_style":"dotted_open","edge_label":...}]} + orchestration_action -> + {"compact_orchestration_actions":[{"resource_types":[...],"command_properties":[...], + "target_properties":[...],"evidence_properties":[...]}]} + concept_node -> + {"compact_concept_nodes":[{"via_resource_types":[...],"controller_property":"...", + "source_property":"...","id_suffix":"...","resource_type":"CONCEPT::...","label":...}]} + container -> {"network_layer_types":[...],"containment_layer_types":{"role":[...]}} +- Prefer conservative `needs_review` when evidence is weak. +""" + +DEFAULT_ACTIONABLE_SIGNAL_CATEGORIES = ( + "container", + "attachment", + "bridge_attachment", + "attachment_edge", + "orchestration_action", + "concept_node", +) +PROMPT_VERSION = "ros-architecture-draft-rules-v2-bilingual-labels" + + +def default_output_dir() -> Path: + return get_config_dir() / "architecture" + + +def default_facts_path() -> Path: + return default_output_dir() / "ros-resource-facts.json" + + +def default_cache_path() -> Path: + return default_output_dir() / "ros-draft-rules-cache.json" + + +def default_draft_out() -> Path: + return default_output_dir() / "ros-draft-rules.json" + + +def default_review_out() -> Path: + return default_output_dir() / "ros-draft-rules-review.md" + + +def default_final_report_out() -> Path: + return default_output_dir() / "ros-draft-rules-final-report.md" + + +def default_rules_diff_out() -> Path: + return default_output_dir() / "ros-draft-rules-diff-summary.json" + + +def default_backup_path() -> Path: + return default_output_dir() / "architecture_rules.json.backup" + + +def chunk_resource_facts( + facts_payload: dict[str, Any], + *, + max_facts_per_chunk: int = 40, + mode: str = "product", + actionable_only: bool = False, + signal_categories: tuple[str, ...] | None = None, + signal_confidences: tuple[str, ...] | None = None, + max_chunks: int | None = None, +) -> list[dict[str, Any]]: + facts = [fact for fact in facts_payload.get("resource_facts", []) if isinstance(fact, dict)] + signals = [signal for signal in facts_payload.get("rule_signals", []) if isinstance(signal, dict)] + categories = tuple(signal_categories or ()) + confidences = tuple(signal_confidences or ()) + selected_resource_types = { + signal["resource_type"] + for signal in signals + if isinstance(signal.get("resource_type"), str) + and _include_signal_in_llm_prompt(signal) + and _signal_category_allowed(signal, categories) + and _signal_confidence_allowed(signal, confidences) + } + if actionable_only: + facts = [fact for fact in facts if fact.get("resource_type") in selected_resource_types] + signals = [ + signal + for signal in signals + if signal.get("resource_type") in selected_resource_types + and _include_signal_in_llm_prompt(signal) + and _signal_category_allowed(signal, categories) + and _signal_confidence_allowed(signal, confidences) + ] + elif categories: + signals = [signal for signal in signals if _signal_category_allowed(signal, categories)] + if confidences and not actionable_only: + signals = [signal for signal in signals if _signal_confidence_allowed(signal, confidences)] + signals_by_resource: dict[str, list[dict[str, Any]]] = {} + for signal in signals: + resource_type = signal.get("resource_type") + if isinstance(resource_type, str): + signals_by_resource.setdefault(resource_type, []).append(signal) + + facts_by_product: dict[str, list[dict[str, Any]]] = {} + for fact in facts: + product_code = fact.get("product_code") + if isinstance(product_code, str) and product_code: + facts_by_product.setdefault(product_code, []).append(fact) + + if mode == "global": + sorted_facts = sorted( + facts, + key=lambda item: (str(item.get("product_code") or ""), str(item.get("resource_type") or "")), + ) + chunks: list[dict[str, Any]] = [] + chunk_size = max(1, max_facts_per_chunk) + for index in range(0, len(sorted_facts), chunk_size): + current_facts = sorted_facts[index : index + chunk_size] + current_resource_types = { + fact["resource_type"] for fact in current_facts if isinstance(fact.get("resource_type"), str) + } + chunks.append( + { + "chunk_id": f"all-{index // chunk_size + 1}", + "product_code": "all", + "resource_facts": current_facts, + "rule_signals": [ + signal + for resource_type in sorted(current_resource_types) + for signal in signals_by_resource.get(resource_type, []) + ], + } + ) + return chunks[:max_chunks] if max_chunks is not None else chunks + + chunks: list[dict[str, Any]] = [] + for product_code in sorted(facts_by_product): + product_facts = sorted(facts_by_product[product_code], key=lambda item: str(item.get("resource_type") or "")) + for index in range(0, len(product_facts), max(1, max_facts_per_chunk)): + current_facts = product_facts[index : index + max(1, max_facts_per_chunk)] + suffix = "" if len(product_facts) <= max_facts_per_chunk else f"-{index // max_facts_per_chunk + 1}" + current_resource_types = { + fact["resource_type"] for fact in current_facts if isinstance(fact.get("resource_type"), str) + } + chunks.append( + { + "chunk_id": f"{product_code}{suffix}", + "product_code": product_code, + "resource_facts": current_facts, + "rule_signals": [ + signal + for resource_type in sorted(current_resource_types) + for signal in signals_by_resource.get(resource_type, []) + ], + } + ) + return chunks[:max_chunks] if max_chunks is not None else chunks + + +def build_draft_rules_prompt(chunk: dict[str, Any]) -> str: + compact_chunk = _compact_chunk_for_llm(chunk) + return ( + "Create draft architecture rules for this Resource Facts / Rule Signals chunk.\n" + "Return JSON only.\n\n" + "For label and edge_label, prefer bilingual objects like " + "{\"zh\":\"中文短标签\",\"en\":\"English short label\"}; " + "use null only when the classification does not render a visible label.\n\n" + f"{json.dumps(compact_chunk, ensure_ascii=False)}" + ) + + +def chunk_fingerprint(chunk: dict[str, Any]) -> str: + compact_chunk = _compact_chunk_for_llm(chunk) + payload = json.dumps( + {"prompt_version": PROMPT_VERSION, "chunk": compact_chunk}, + ensure_ascii=False, + sort_keys=True, + ) + return hashlib.sha256(payload.encode("utf-8")).hexdigest() + + +async def complete_chunk_with_llm(prompt: str, *, model: str) -> str: + manager = ProviderManager(model=model, credentials=load_credentials(model=model)) + response = await manager.complete([Message.user(prompt)], SYSTEM_PROMPT, max_tokens=4000) + return response.text + + +def run_draft_generation_from_facts_payload( + facts_payload: dict[str, Any], + *, + cache_path: Path, + max_facts_per_chunk: int, + complete_chunk: Callable[[str], str | Awaitable[str]], + chunk_mode: str = "product", + actionable_only: bool = False, + signal_categories: tuple[str, ...] | None = None, + signal_confidences: tuple[str, ...] | None = None, + max_chunks: int | None = None, +) -> dict[str, Any]: + return asyncio.run( + run_draft_generation_from_facts_payload_async( + facts_payload, + cache_path=cache_path, + max_facts_per_chunk=max_facts_per_chunk, + complete_chunk=complete_chunk, + chunk_mode=chunk_mode, + actionable_only=actionable_only, + signal_categories=signal_categories, + signal_confidences=signal_confidences, + max_chunks=max_chunks, + ) + ) + + +async def run_draft_generation_from_facts_payload_async( + facts_payload: dict[str, Any], + *, + cache_path: Path, + max_facts_per_chunk: int, + complete_chunk: Callable[[str], str | Awaitable[str]], + chunk_mode: str = "product", + actionable_only: bool = False, + signal_categories: tuple[str, ...] | None = None, + signal_confidences: tuple[str, ...] | None = None, + max_chunks: int | None = None, +) -> dict[str, Any]: + cache = _load_cache(cache_path) + chunks_cache = cache.setdefault("chunks", {}) + draft_rules: list[dict[str, Any]] = [] + chunk_summaries: list[dict[str, Any]] = [] + parse_errors = 0 + categories = tuple(signal_categories or ()) + confidences = tuple(signal_confidences or ()) + + chunks = chunk_resource_facts( + facts_payload, + max_facts_per_chunk=max_facts_per_chunk, + mode=chunk_mode, + actionable_only=actionable_only, + signal_categories=categories, + signal_confidences=confidences, + max_chunks=max_chunks, + ) + for chunk in chunks: + chunk_id = chunk["chunk_id"] + fingerprint = chunk_fingerprint(chunk) + cached = chunks_cache.get(chunk_id) + if ( + isinstance(cached, dict) + and cached.get("fingerprint") == fingerprint + and isinstance(cached.get("response_text"), str) + ): + response_text = cached["response_text"] + from_cache = True + else: + response_text = await _run_complete_chunk(complete_chunk, build_draft_rules_prompt(chunk)) + chunks_cache[chunk_id] = {"fingerprint": fingerprint, "response_text": response_text} + _write_cache(cache_path, cache) + from_cache = False + parse_error = None + try: + parsed = [draft.to_dict() for draft in parse_draft_rules_response(response_text)] + except ValueError as exc: + parsed = [] + parse_error = str(exc) + parse_errors += 1 + draft_rules.extend(parsed) + summary = { + "chunk_id": chunk_id, + "from_cache": from_cache, + "resource_facts": len(chunk["resource_facts"]), + "draft_rules": len(parsed), + } + if parse_error is not None: + summary["parse_error"] = parse_error + chunk_summaries.append(summary) + + _write_cache(cache_path, cache) + draft_rules.sort(key=lambda item: (item.get("resource_type") or "", item.get("classification") or "")) + return { + "summary": { + "chunks": chunk_summaries, + "draft_rules": len(draft_rules), + "parse_errors": parse_errors, + "input_resource_facts": len( + [fact for fact in facts_payload.get("resource_facts", []) if isinstance(fact, dict)] + ), + "llm_resource_facts": sum(len(chunk.get("resource_facts", [])) for chunk in chunks), + "actionable_only": actionable_only, + "signal_categories": list(categories), + "signal_confidences": list(confidences), + }, + "draft_rules": draft_rules, + } + + +def build_facts_bundle_from_payload(payload: dict[str, Any]) -> ResourceRuleFactsBundle: + facts = tuple( + ResourceRuleFact( + resource_type=fact["resource_type"], + product_code=fact.get("product_code") or "", + source_state=fact.get("source_state") or "", + name=fact.get("name") if isinstance(fact.get("name"), dict) else {"zh": None, "en": None}, + description=fact.get("description") if isinstance(fact.get("description"), str) else None, + category_code=fact.get("category_code") if isinstance(fact.get("category_code"), str) else None, + properties=fact.get("properties") if isinstance(fact.get("properties"), dict) else {}, + related_properties=( + fact.get("related_properties") if isinstance(fact.get("related_properties"), dict) else {} + ), + main_resource_type=( + fact.get("main_resource_type") if isinstance(fact.get("main_resource_type"), dict) else None + ), + fixed_rule_hits=tuple( + item for item in fact.get("fixed_rule_hits", []) if isinstance(item, str) + ), + ) + for fact in payload.get("resource_facts", []) + if isinstance(fact, dict) and isinstance(fact.get("resource_type"), str) + ) + signals = tuple( + RuleSignal( + category=signal.get("category") or "", + resource_type=signal.get("resource_type") or "", + product_code=signal.get("product_code") or "", + property_name=signal.get("property_name") if isinstance(signal.get("property_name"), str) else None, + target_resource_types=tuple( + item for item in signal.get("target_resource_types", []) if isinstance(item, str) + ), + confidence=signal.get("confidence") or "", + evidence=tuple(item for item in signal.get("evidence", []) if isinstance(item, str)), + suggested_patch=signal.get("suggested_patch") if isinstance(signal.get("suggested_patch"), dict) else {}, + ) + for signal in payload.get("rule_signals", []) + if isinstance(signal, dict) and isinstance(signal.get("resource_type"), str) + ) + summary_raw = payload.get("summary") + summary: dict[str, Any] = summary_raw if isinstance(summary_raw, dict) else {} + return ResourceRuleFactsBundle( + resource_facts=facts, + rule_signals=signals, + api_resource_type_count=int(summary.get("api_resource_types") or len(facts)), + local_resource_type_count=int(summary.get("local_resource_types") or 0), + api_only_resource_types=(), + local_only_resource_types=(), + fetch_errors={}, + ) + + +def load_existing_draft_result(path: Path) -> dict[str, Any]: + value = json.loads(path.read_text(encoding="utf-8")) + if not isinstance(value, dict) or not isinstance(value.get("draft_rules"), list): + raise ValueError("draft result must be a JSON object with draft_rules list") + summary = value.get("summary") if isinstance(value.get("summary"), dict) else {} + return {"summary": summary, "draft_rules": value["draft_rules"]} + + +def filter_draft_result(result: dict[str, Any], *, reject_resource_types: tuple[str, ...]) -> dict[str, Any]: + rejected = set(reject_resource_types) + if not rejected: + return result + draft_rules = [ + draft + for draft in result.get("draft_rules", []) + if not (isinstance(draft, dict) and draft.get("resource_type") in rejected) + ] + summary_raw = result.get("summary") + summary: dict[str, Any] = dict(summary_raw) if isinstance(summary_raw, dict) else {} + summary["draft_rules"] = len(draft_rules) + summary["subagent_rejected_resource_types"] = sorted(rejected) + return {"summary": summary, "draft_rules": draft_rules} + + +def summarize_rules_diff(before: dict[str, Any], after: dict[str, Any]) -> dict[str, dict[str, int | bool]]: + summary: dict[str, dict[str, int | bool]] = {} + for key in sorted(set(before) | set(after)): + before_value = before.get(key) + after_value = after.get(key) + if isinstance(before_value, list) or isinstance(after_value, list): + before_len = len(before_value) if isinstance(before_value, list) else 0 + after_len = len(after_value) if isinstance(after_value, list) else 0 + if before_len != after_len: + summary[key] = { + "before": before_len, + "after": after_len, + "added": max(0, after_len - before_len), + "removed": max(0, before_len - after_len), + } + elif isinstance(before_value, dict) or isinstance(after_value, dict): + before_dict = before_value if isinstance(before_value, dict) else {} + after_dict = after_value if isinstance(after_value, dict) else {} + added = set(after_dict) - set(before_dict) + removed = set(before_dict) - set(after_dict) + changed = { + item + for item in set(before_dict) & set(after_dict) + if json.dumps(before_dict[item], ensure_ascii=False, sort_keys=True) + != json.dumps(after_dict[item], ensure_ascii=False, sort_keys=True) + } + if added or removed or changed: + summary[key] = { + "before": len(before_dict), + "after": len(after_dict), + "dict_added": len(added), + "dict_removed": len(removed), + "dict_changed": len(changed), + } + elif before_value != after_value: + summary[key] = {"changed": True} + return summary + + +def render_final_report_markdown( + *, + facts_payload: dict[str, Any], + draft_result: dict[str, Any], + review_markdown: str, + diff_summary: dict[str, dict[str, int | bool]], + paths: dict[str, str], + verification_results: list[str] | None = None, + blockers: list[str] | None = None, +) -> str: + facts_summary_raw = facts_payload.get("summary") + facts_summary: dict[str, Any] = facts_summary_raw if isinstance(facts_summary_raw, dict) else {} + draft_summary_raw = draft_result.get("summary") + draft_summary: dict[str, Any] = draft_summary_raw if isinstance(draft_summary_raw, dict) else {} + accepted, rejected = _extract_review_counts(review_markdown) + lines = [ + "# ROS 架构图规则提取最终报告", + "", + "## Summary", + "", + "| Metric | Value |", + "| --- | ---: |", + f"| ROS API 资源类型 | {facts_summary.get('api_resource_types', '-')} |", + f"| Resource Facts | {facts_summary.get('resource_facts', '-')} |", + f"| Rule Signals | {facts_summary.get('rule_signals', '-')} |", + f"| LLM 输入资源类型 | {draft_summary.get('llm_resource_facts', '-')} |", + f"| LLM 草案数量 | {draft_summary.get('draft_rules', 0)} |", + f"| LLM 解析错误 | {draft_summary.get('parse_errors', 0)} |", + f"| Review 通过 | {accepted if accepted is not None else '-'} |", + f"| Review 拒绝 | {rejected if rejected is not None else '-'} |", + "", + "## Artifacts", + "", + "| Artifact | Path |", + "| --- | --- |", + ] + for name in sorted(paths): + lines.append(f"| {name} | `{paths[name]}` |") + lines.extend(["", "## architecture_rules.json Diff Summary", ""]) + if diff_summary: + lines.extend(["| Rule key | Summary |", "| --- | --- |"]) + for key, value in sorted(diff_summary.items()): + parts = [f"{field}={count}" for field, count in value.items()] + lines.append(f"| `{key}` | {', '.join(parts)} |") + else: + lines.append("No accepted rule changed `architecture_rules.json`.") + lines.extend(["", "## Verification", ""]) + for item in verification_results or []: + lines.append(f"- {item}") + if not verification_results: + lines.append("- Not run yet.") + lines.extend(["", "## Blockers", ""]) + if blockers: + for blocker in blockers: + lines.append(f"- {blocker}") + else: + lines.append("- None recorded.") + return "\n".join(lines).rstrip() + "\n" + + +def parse_args(argv: list[str]) -> argparse.Namespace: + parser = argparse.ArgumentParser(description="Generate LLM draft ROS architecture rules from resource facts.") + parser.add_argument("--facts-json", type=Path, default=None, help="Resource facts JSON path.") + parser.add_argument("--cache", type=Path, default=None, help="Draft generation cache path.") + parser.add_argument("--draft-in", type=Path, default=None, help="Existing draft rules JSON to review/apply.") + parser.add_argument("--draft-out", type=Path, default=None, help="Draft rules JSON output path.") + parser.add_argument("--review-out", type=Path, default=None, help="Draft review Markdown output path.") + parser.add_argument("--final-report-out", type=Path, default=None, help="Final Markdown report output path.") + parser.add_argument("--rules-diff-out", type=Path, default=None, help="Rule diff summary JSON output path.") + parser.add_argument("--rules-in", type=Path, default=None, help="architecture_rules.json input path.") + parser.add_argument("--rules-out", type=Path, default=None, help="architecture_rules.json output path.") + parser.add_argument("--backup-path", type=Path, default=None, help="Required backup path when --apply is used.") + parser.add_argument("--apply", action="store_true", help="Apply accepted reviewed patches to rules-out.") + parser.add_argument("--model", default=None, help="Override model. Defaults to saved iac-code model.") + parser.add_argument("--max-facts-per-chunk", type=int, default=40, help="Maximum facts per LLM chunk.") + parser.add_argument("--max-chunks", type=int, default=None, help="Maximum LLM chunks to process this run.") + parser.add_argument( + "--actionable-only", + action="store_true", + help="Only send resources with selected non-display rule signals to the LLM.", + ) + parser.add_argument( + "--signal-categories", + default=",".join(DEFAULT_ACTIONABLE_SIGNAL_CATEGORIES), + help="Comma-separated rule signal categories to send to the LLM when filtering.", + ) + parser.add_argument( + "--signal-confidences", + default="", + help="Optional comma-separated signal confidence values to send to the LLM, such as high,medium.", + ) + parser.add_argument( + "--reject-resource-types", + default="", + help="Comma-separated resource types rejected by subagent review before applying patches.", + ) + parser.add_argument( + "--chunk-mode", + choices=("product", "global"), + default="product", + help="Chunking strategy. product keeps product boundaries; global packs products into fewer LLM calls.", + ) + parser.add_argument("--print-raw", action="store_true", help="Print generated draft JSON.") + return parser.parse_args(argv) + + +async def async_cli_main(argv: list[str]) -> int: + args = parse_args(argv) + console = Console() + facts_path = args.facts_json or default_facts_path() + cache_path = args.cache or default_cache_path() + draft_out = args.draft_out or default_draft_out() + review_out = args.review_out or default_review_out() + final_report_out = args.final_report_out or default_final_report_out() + rules_diff_out = args.rules_diff_out or default_rules_diff_out() + rules_in = args.rules_in or Path("src/iac_code/pipeline/engine/architecture_rules.json") + rules_out = args.rules_out or rules_in + backup_path = args.backup_path or default_backup_path() + model = args.model or load_saved_model() or DEFAULT_MODEL + signal_categories = _parse_signal_categories(args.signal_categories) + signal_confidences = _parse_csv_tuple(args.signal_confidences) + reject_resource_types = _parse_csv_tuple(args.reject_resource_types) + + facts_payload = json.loads(facts_path.read_text(encoding="utf-8")) + + async def real_complete(prompt: str) -> str: + return await complete_chunk_with_llm(prompt, model=model) + + if args.draft_in is not None: + result = load_existing_draft_result(args.draft_in) + else: + result = await run_draft_generation_from_facts_payload_async( + facts_payload, + cache_path=cache_path, + max_facts_per_chunk=args.max_facts_per_chunk, + chunk_mode=args.chunk_mode, + actionable_only=args.actionable_only, + signal_categories=signal_categories, + signal_confidences=signal_confidences, + max_chunks=args.max_chunks, + complete_chunk=real_complete, + ) + draft_out.parent.mkdir(parents=True, exist_ok=True) + draft_out.write_text(json.dumps(result, ensure_ascii=False, indent=2, sort_keys=True), encoding="utf-8") + result = filter_draft_result(result, reject_resource_types=reject_resource_types) + + facts_bundle = build_facts_bundle_from_payload(facts_payload) + drafts = parse_draft_rules_response(json.dumps({"draft_rules": result["draft_rules"]}, ensure_ascii=False)) + reviewed = review_valid_draft_rules(validate_draft_rules(drafts, facts_bundle)) + review_out.parent.mkdir(parents=True, exist_ok=True) + review_markdown = render_draft_review_report_markdown(reviewed) + review_out.write_text(review_markdown, encoding="utf-8") + diff_summary: dict[str, dict[str, int | bool]] = {} + + if args.apply: + if not backup_path.is_file(): + console.print(f"[red]Backup is required before applying rules: {backup_path}[/]") + return 2 + raw_rules = json.loads(rules_in.read_text(encoding="utf-8")) + updated = apply_reviewed_draft_patches(raw_rules, reviewed, facts=facts_bundle) + diff_summary = summarize_rules_diff(raw_rules, updated) + rules_out.parent.mkdir(parents=True, exist_ok=True) + rules_out.write_text( + json.dumps(updated, ensure_ascii=False, indent=2, sort_keys=True) + "\n", + encoding="utf-8", + ) + rules_diff_out.parent.mkdir(parents=True, exist_ok=True) + rules_diff_out.write_text( + json.dumps(diff_summary, ensure_ascii=False, indent=2, sort_keys=True), + encoding="utf-8", + ) + + final_report = render_final_report_markdown( + facts_payload=facts_payload, + draft_result=result, + review_markdown=review_markdown, + diff_summary=diff_summary, + paths={ + "facts": str(facts_path), + "draft": str(draft_out if args.draft_in is None else args.draft_in), + "review": str(review_out), + "rules": str(rules_out), + "rules_diff": str(rules_diff_out), + }, + ) + final_report_out.parent.mkdir(parents=True, exist_ok=True) + final_report_out.write_text(final_report, encoding="utf-8") + + if args.print_raw: + console.print_json(json.dumps(result, ensure_ascii=False)) + if args.draft_in is None: + console.print(f"[green]Wrote draft rules:[/] {draft_out}") + else: + console.print(f"[green]Loaded draft rules:[/] {args.draft_in}") + console.print(f"[green]Wrote review report:[/] {review_out}") + console.print(f"[green]Wrote final report:[/] {final_report_out}") + console.print(f"[dim]Cache:[/] {cache_path}") + return 0 + + +def main() -> None: + raise SystemExit(asyncio.run(async_cli_main(sys.argv[1:]))) + + +def _load_cache(cache_path: Path) -> dict[str, Any]: + if not cache_path.exists(): + return {"chunks": {}} + try: + value = json.loads(cache_path.read_text(encoding="utf-8")) + except json.JSONDecodeError: + return {"chunks": {}} + return value if isinstance(value, dict) else {"chunks": {}} + + +def _write_cache(cache_path: Path, cache: dict[str, Any]) -> None: + cache_path.parent.mkdir(parents=True, exist_ok=True) + cache_path.write_text(json.dumps(cache, ensure_ascii=False, indent=2, sort_keys=True), encoding="utf-8") + + +async def _run_complete_chunk(complete_chunk: Callable[[str], str | Awaitable[str]], prompt: str) -> str: + value = complete_chunk(prompt) + if inspect.isawaitable(value): + return await cast(Awaitable[str], value) + return value + + +def _compact_chunk_for_llm(chunk: dict[str, Any]) -> dict[str, Any]: + return { + "chunk_id": chunk.get("chunk_id"), + "product_code": chunk.get("product_code"), + "resource_facts": [_compact_fact(fact) for fact in chunk.get("resource_facts", []) if isinstance(fact, dict)], + "rule_signals": [ + _compact_signal(signal) + for signal in chunk.get("rule_signals", []) + if isinstance(signal, dict) and _include_signal_in_llm_prompt(signal) + ], + } + + +def _compact_fact(fact: dict[str, Any]) -> dict[str, Any]: + properties_raw = fact.get("properties") + properties: dict[str, Any] = properties_raw if isinstance(properties_raw, dict) else {} + related_properties_raw = fact.get("related_properties") + related_properties: dict[str, Any] = ( + related_properties_raw if isinstance(related_properties_raw, dict) else {} + ) + main_resource_type_raw = fact.get("main_resource_type") + main_resource_type: dict[str, Any] | None = ( + main_resource_type_raw if isinstance(main_resource_type_raw, dict) else None + ) + return { + "resource_type": fact.get("resource_type"), + "product_code": fact.get("product_code"), + "source_state": fact.get("source_state"), + "name": fact.get("name"), + "description": _shorten(fact.get("description"), limit=120), + "category_code": fact.get("category_code"), + "property_names": sorted(name for name in properties if isinstance(name, str)), + "properties": _compact_properties(properties, related_properties, main_resource_type), + "related_properties": related_properties, + "main_resource_type": main_resource_type, + "fixed_rule_hits": fact.get("fixed_rule_hits") if isinstance(fact.get("fixed_rule_hits"), list) else [], + } + + +def _compact_properties( + raw: Any, + related_properties: dict[str, Any], + main_resource_type: dict[str, Any] | None, +) -> dict[str, dict[str, Any]]: + if not isinstance(raw, dict): + return {} + interesting_names = set(related_properties) + if main_resource_type is not None and isinstance(main_resource_type.get("ref_property"), str): + interesting_names.add(main_resource_type["ref_property"]) + compact: dict[str, dict[str, Any]] = {} + selected = 0 + for name, value in sorted(raw.items()): + if not isinstance(name, str) or not isinstance(value, dict): + continue + property_info = cast(dict[str, Any], value) + if name not in interesting_names and not _looks_interesting_property_name(name): + continue + if selected >= 24 and name not in interesting_names: + continue + compact[name] = { + "type": property_info.get("type"), + "required": property_info.get("required"), + "description": _shorten(property_info.get("description"), limit=100), + "related_targets": property_info.get("related_targets") + if isinstance(property_info.get("related_targets"), list) + else [], + } + selected += 1 + return compact + + +def _compact_signal(signal: dict[str, Any]) -> dict[str, Any]: + return { + "category": signal.get("category"), + "resource_type": signal.get("resource_type"), + "property_name": signal.get("property_name"), + "target_resource_types": signal.get("target_resource_types") + if isinstance(signal.get("target_resource_types"), list) + else [], + "confidence": signal.get("confidence"), + "evidence": [_shorten(item) for item in signal.get("evidence", []) if isinstance(item, str)], + } + + +def _include_signal_in_llm_prompt(signal: dict[str, Any]) -> bool: + category = signal.get("category") + if category == "display": + return False + if category == "supplemental_relation": + targets = signal.get("target_resource_types") + return isinstance(targets, list) and bool(targets) + return True + + +def _signal_category_allowed(signal: dict[str, Any], categories: tuple[str, ...]) -> bool: + if not categories: + return True + return signal.get("category") in categories + + +def _signal_confidence_allowed(signal: dict[str, Any], confidences: tuple[str, ...]) -> bool: + if not confidences: + return True + return signal.get("confidence") in confidences + + +def _parse_signal_categories(raw: str) -> tuple[str, ...]: + categories = _parse_csv_tuple(raw) + return categories or DEFAULT_ACTIONABLE_SIGNAL_CATEGORIES + + +def _parse_csv_tuple(raw: str) -> tuple[str, ...]: + return tuple(item.strip() for item in raw.split(",") if item.strip()) + + +def _extract_review_counts(markdown: str) -> tuple[int | None, int | None]: + accepted = None + rejected = None + for line in markdown.splitlines(): + normalized = line.strip() + if normalized.startswith("| Accepted |"): + accepted = _last_table_int(normalized) + elif normalized.startswith("| Rejected |"): + rejected = _last_table_int(normalized) + return accepted, rejected + + +def _last_table_int(line: str) -> int | None: + parts = [part.strip() for part in line.strip("|").split("|")] + for part in reversed(parts): + try: + return int(part) + except ValueError: + continue + return None + + +def _shorten(value: Any, *, limit: int = 220) -> str | None: + if not isinstance(value, str): + return None + text = " ".join(value.split()) + if len(text) <= limit: + return text + return text[: limit - 3] + "..." + + +def _looks_interesting_property_name(name: str) -> bool: + lowered = name.lower() + return lowered.endswith(("id", "ids", "name", "names")) or any( + token in lowered + for token in ( + "access", + "bandwidth", + "command", + "eip", + "entry", + "gateway", + "group", + "instance", + "mount", + "package", + "policy", + "rule", + "table", + "target", + "vpc", + "vswitch", + ) + ) + + +if __name__ == "__main__": + main() diff --git a/scripts/rendering/preview_template_architecture_llm.py b/scripts/rendering/preview_template_architecture_llm.py new file mode 100644 index 00000000..ccf4343d --- /dev/null +++ b/scripts/rendering/preview_template_architecture_llm.py @@ -0,0 +1,43 @@ +#!/usr/bin/env python3 +"""Preview a ROS template architecture diagram with a real LLM semantic pass.""" + +from __future__ import annotations + +from iac_code.pipeline.engine import architecture_semantic_planning as _impl + +globals().update( + { + name: getattr(_impl, name) + for name in dir(_impl) + if not (name.startswith("__") and name.endswith("__")) + } +) + + +def _call_with_patchable_hooks(function, *args, **kwargs): + hook_names = ("_render_terminal_rich", "_svg_to_png_command") + original_hooks = {name: getattr(_impl, name) for name in hook_names} + try: + for name in hook_names: + if name in globals(): + setattr(_impl, name, globals()[name]) + return function(*args, **kwargs) + finally: + for name, value in original_hooks.items(): + setattr(_impl, name, value) + + +def write_terminal_svg(*args, **kwargs): + return _call_with_patchable_hooks(_impl.write_terminal_svg, *args, **kwargs) + + +def write_terminal_png(*args, **kwargs): + return _call_with_patchable_hooks(_impl.write_terminal_png, *args, **kwargs) + + +def convert_svg_to_png(*args, **kwargs): + return _call_with_patchable_hooks(_impl.convert_svg_to_png, *args, **kwargs) + + +if __name__ == "__main__": + _impl.main() diff --git a/src/iac_code/a2a/pipeline_events.py b/src/iac_code/a2a/pipeline_events.py index c1295c4b..cd9240f5 100644 --- a/src/iac_code/a2a/pipeline_events.py +++ b/src/iac_code/a2a/pipeline_events.py @@ -1477,9 +1477,13 @@ def _diagram_data(event: DiagramEvent) -> dict[str, Any]: "templateContent": event.template_content, "mermaidSource": event.mermaid_source, "format": "mermaid", + "diagramStage": event.diagram_stage, + "views": event.views, } if event.candidate_index is not None: data["candidateIndex"] = event.candidate_index + if event.architecture_context is not None: + data["architectureContext"] = event.architecture_context return data diff --git a/src/iac_code/agent/agent_loop.py b/src/iac_code/agent/agent_loop.py index 82d1025b..4767a6e2 100644 --- a/src/iac_code/agent/agent_loop.py +++ b/src/iac_code/agent/agent_loop.py @@ -32,6 +32,11 @@ from iac_code.tools.tool_executor import ToolCallRequest, ToolExecutor from iac_code.types.permissions import PermissionAuditSettings, PermissionResult from iac_code.types.stream_events import ( + TOOL_RENDER_DISPLAY_NAME_KEY, + TOOL_RENDER_METADATA_KEY, + TOOL_RENDER_RESULT_COMPACT_KEY, + TOOL_RENDER_RESULT_VERBOSE_KEY, + TOOL_RENDER_VERBOSE_RESULT_IN_TRANSCRIPT_KEY, CompactionEvent, MessageEndEvent, PermissionRequestEvent, @@ -925,7 +930,13 @@ async def _run_streaming_inner( tools=provider_tools, ): if isinstance(event, ToolUseStartEvent): - event = replace(event, renderer_tool=self.tool_registry.get(event.name)) + event = replace( + event, + metadata=self._tool_use_start_metadata( + event.metadata, + self.tool_registry.get(event.name), + ), + ) yield event # Forward all provider events to UI # Collect data from events @@ -1234,6 +1245,12 @@ async def poll_event_queues(): processed = self._result_storage.process(req.id, result.content) self._mark_read_memory_tool_result(req, result) result_metadata = self._tool_result_event_metadata(result.metadata, processed) + result_metadata = self._tool_result_render_metadata( + result_metadata, + self.tool_registry.get(req.name), + processed.content, + is_error=result.is_error, + ) yield ToolResultEvent( tool_use_id=req.id, @@ -1312,6 +1329,72 @@ def _tool_result_event_metadata(metadata: dict[str, Any] | None, processed: Any) event_metadata[EXTERNALIZED_RESULT_PATH_METADATA_KEY] = str(processed.file_path) return event_metadata + @staticmethod + def _merge_tool_render_metadata( + metadata: dict[str, Any] | None, + render_metadata: dict[str, Any], + ) -> dict[str, Any] | None: + if not render_metadata: + return metadata + merged = dict(metadata or {}) + existing = merged.get(TOOL_RENDER_METADATA_KEY) + if isinstance(existing, dict): + render_metadata = {**existing, **render_metadata} + merged[TOOL_RENDER_METADATA_KEY] = render_metadata + return merged + + @classmethod + def _tool_use_start_metadata(cls, metadata: dict[str, Any] | None, tool: Any | None) -> dict[str, Any] | None: + if tool is None: + return metadata + + render_metadata: dict[str, Any] = {} + user_facing_name = getattr(tool, "user_facing_name", None) + if callable(user_facing_name): + try: + display_name = user_facing_name({}) + except Exception: + display_name = None + if isinstance(display_name, str) and display_name and display_name != getattr(tool, "name", None): + render_metadata[TOOL_RENDER_DISPLAY_NAME_KEY] = display_name + + if bool(getattr(tool, "render_verbose_result_in_transcript", False)): + render_metadata[TOOL_RENDER_VERBOSE_RESULT_IN_TRANSCRIPT_KEY] = True + + return cls._merge_tool_render_metadata(metadata, render_metadata) + + @classmethod + def _tool_result_render_metadata( + cls, + metadata: dict[str, Any] | None, + tool: Any | None, + output: str, + *, + is_error: bool, + ) -> dict[str, Any] | None: + render_result = getattr(tool, "render_tool_result_message", None) + if not callable(render_result): + return metadata + + render_metadata: dict[str, Any] = {} + try: + compact = render_result(output, is_error=is_error, verbose=False) + except Exception: + compact = None + if isinstance(compact, str) and compact: + render_metadata[TOOL_RENDER_RESULT_COMPACT_KEY] = compact + + if bool(getattr(tool, "render_verbose_result_in_transcript", False)): + render_metadata[TOOL_RENDER_VERBOSE_RESULT_IN_TRANSCRIPT_KEY] = True + try: + verbose = render_result(output, is_error=is_error, verbose=True) + except Exception: + verbose = None + if isinstance(verbose, str) and verbose: + render_metadata[TOOL_RENDER_RESULT_VERBOSE_KEY] = verbose + + return cls._merge_tool_render_metadata(metadata, render_metadata) + @staticmethod def _tool_result_block_metadata(processed: Any) -> dict[str, Any]: if not getattr(processed, "is_externalized", False) or not getattr(processed, "file_path", None): diff --git a/src/iac_code/cli/output_formats.py b/src/iac_code/cli/output_formats.py index 871adae7..ce6306a9 100644 --- a/src/iac_code/cli/output_formats.py +++ b/src/iac_code/cli/output_formats.py @@ -15,6 +15,7 @@ from iac_code.services.permissions.audit import build_input_summary from iac_code.tools.result_storage import EXTERNALIZED_RESULT_PATH_METADATA_KEY from iac_code.types.stream_events import ( + TOOL_RENDER_METADATA_KEY, ErrorEvent, MessageEndEvent, PermissionRequestEvent, @@ -57,7 +58,7 @@ def _strip_internal_tool_metadata(metadata: Any) -> Any: return { str(key): _strip_internal_tool_metadata(value) for key, value in metadata.items() - if key != EXTERNALIZED_RESULT_PATH_METADATA_KEY + if key not in {EXTERNALIZED_RESULT_PATH_METADATA_KEY, TOOL_RENDER_METADATA_KEY} } if isinstance(metadata, list): return [_strip_internal_tool_metadata(item) for item in metadata] @@ -133,6 +134,8 @@ def _stream_json_event_data(event: StreamEvent) -> dict[str, Any]: data.pop("metadata", None) elif "metadata" in data: data["metadata"] = _public_tool_metadata(event, data["metadata"]) + if data["metadata"] == {}: + data.pop("metadata", None) data["result"] = _public_tool_result(event) return data diff --git a/src/iac_code/i18n/locales/de/LC_MESSAGES/messages.po b/src/iac_code/i18n/locales/de/LC_MESSAGES/messages.po index 6b5caadd..c0a26806 100644 --- a/src/iac_code/i18n/locales/de/LC_MESSAGES/messages.po +++ b/src/iac_code/i18n/locales/de/LC_MESSAGES/messages.po @@ -2958,6 +2958,63 @@ msgstr "ROS-Bereitstellung" msgid "InfraGuard scan" msgstr "InfraGuard-Scan" +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "ECS instance" +msgstr "ECS-Instanz" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "ECS instance group" +msgstr "ECS-Instanzgruppe" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "Elastic IP address" +msgstr "Elastische IP-Adresse" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "SLB load balancer" +msgstr "SLB-Load-Balancer" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "NAT gateway" +msgstr "NAT-Gateway" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "Shared bandwidth package" +msgstr "Paket für gemeinsam genutzte Bandbreite" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "Database instance" +msgstr "Datenbankinstanz" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "VPC" +msgstr "VPC" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "VSwitch" +msgstr "VSwitch" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "Security group" +msgstr "Sicherheitsgruppe" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "YAML parse error" +msgstr "YAML-Analysefehler" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "related resource" +msgstr "zugehörige Ressource" + +#: src/iac_code/pipeline/engine/architecture_graph.py +#: src/iac_code/ui/components/candidate_selection.py +msgid "Architecture overview" +msgstr "Architekturübersicht" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "Show the complete architecture diagram." +msgstr "Vollständiges Architekturdiagramm anzeigen." + #: src/iac_code/pipeline/engine/ask_user_question_tool.py msgid "" "Pipeline-only tool that asks the user to choose an option or type " @@ -3626,50 +3683,6 @@ msgstr "Exit-Code {returncode}" msgid "{command} exited with {returncode}: {body}" msgstr "{command} wurde mit {returncode} beendet: {body}" -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "ECS instance" -msgstr "ECS-Instanz" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "ECS instance group" -msgstr "ECS-Instanzgruppe" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "Elastic IP address" -msgstr "Elastische IP-Adresse" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "SLB load balancer" -msgstr "SLB-Load-Balancer" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "NAT gateway" -msgstr "NAT-Gateway" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "Shared bandwidth package" -msgstr "Paket für gemeinsam genutzte Bandbreite" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "Database instance" -msgstr "Datenbankinstanz" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "VPC" -msgstr "VPC" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "VSwitch" -msgstr "VSwitch" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "Security group" -msgstr "Sicherheitsgruppe" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "YAML parse error" -msgstr "YAML-Analysefehler" - #: src/iac_code/pipeline/engine/show_diagram_tool.py msgid "" "Read a ROS template YAML file and generate an architecture diagram. Pass " @@ -3701,11 +3714,34 @@ msgstr "" "Nullbasierter Kandidatenindex in evaluated_candidates; dient zur " "Unterscheidung doppelter Namen" +#: src/iac_code/pipeline/engine/show_diagram_tool.py +msgid "" +"Use facts to emit an immediate draft diagram and internally optimize it " +"with the LLM; use render to emit a diagram from an explicit " +"semantic_plan." +msgstr "" +"Mit facts sofort einen Diagrammentwurf ausgeben und intern mit dem LLM " +"optimieren; mit render ein Diagramm aus einem expliziten semantic_plan " +"ausgeben." + +#: src/iac_code/pipeline/engine/show_diagram_tool.py +msgid "" +"Optional LLM-generated semantic graph plan. Edges must reference visible " +"node ids from a prior facts response." +msgstr "" +"Optionaler vom LLM generierter semantischer Graphplan. Kanten müssen " +"sichtbare Knoten-IDs aus einer vorherigen facts-Antwort referenzieren." + #: src/iac_code/pipeline/engine/show_diagram_tool.py #, python-brace-format msgid "Template file does not exist: {file_path}" msgstr "Template-Datei existiert nicht: {file_path}" +#: src/iac_code/pipeline/engine/show_diagram_tool.py +#, python-brace-format +msgid "Generated and optimized the architecture diagram for \"{candidate_name}\"." +msgstr "Architekturdiagramm für „{candidate_name}“ wurde generiert und optimiert." + #: src/iac_code/pipeline/engine/show_diagram_tool.py #, python-brace-format msgid "Generated the architecture diagram for \"{candidate_name}\"." @@ -6096,6 +6132,10 @@ msgstr "Nach oben scrollen, um mehr zu sehen" msgid "Scroll down to view more" msgstr "Nach unten scrollen, um mehr zu sehen" +#: src/iac_code/ui/components/candidate_selection.py +msgid "架构图优化中..." +msgstr "Architekturdiagramm wird optimiert..." + #: src/iac_code/ui/components/candidate_selection.py msgid "Loading architecture diagram..." msgstr "Architekturdiagramm wird geladen..." @@ -6104,6 +6144,11 @@ msgstr "Architekturdiagramm wird geladen..." msgid "Loading candidate details..." msgstr "Kandidatendetails werden geladen..." +#: src/iac_code/ui/components/candidate_selection.py +#, python-brace-format +msgid "Diagram {index}" +msgstr "Diagramm {index}" + #: src/iac_code/ui/components/candidate_selection.py msgid "" "Press number keys to select a candidate, Enter to confirm | ← → switch " @@ -6127,6 +6172,10 @@ msgstr " | 1-{count} direkt springen" msgid "↑ ↓ scroll" msgstr "↑ ↓ scrollen" +#: src/iac_code/ui/components/candidate_selection.py +msgid "switch diagrams" +msgstr "Diagramme wechseln" + #: src/iac_code/ui/components/fuzzy_picker.py msgid "No matches found" msgstr "Keine Treffer" @@ -6755,3 +6804,33 @@ msgstr "Öffnen einer nicht regulären Datei verweigert: {path}" #~ msgid "feature" #~ msgstr "Funktion" +#~ msgid "ECS instance" +#~ msgstr "ECS-Instanz" + +#~ msgid "ECS instance group" +#~ msgstr "ECS-Instanzgruppe" + +#~ msgid "Elastic IP address" +#~ msgstr "Elastische IP-Adresse" + +#~ msgid "SLB load balancer" +#~ msgstr "SLB-Load-Balancer" + +#~ msgid "NAT gateway" +#~ msgstr "NAT-Gateway" + +#~ msgid "Shared bandwidth package" +#~ msgstr "Paket für gemeinsam genutzte Bandbreite" + +#~ msgid "Database instance" +#~ msgstr "Datenbankinstanz" + +#~ msgid "VPC" +#~ msgstr "VPC" + +#~ msgid "VSwitch" +#~ msgstr "VSwitch" + +#~ msgid "Security group" +#~ msgstr "Sicherheitsgruppe" + diff --git a/src/iac_code/i18n/locales/es/LC_MESSAGES/messages.po b/src/iac_code/i18n/locales/es/LC_MESSAGES/messages.po index 23e5e319..5369b195 100644 --- a/src/iac_code/i18n/locales/es/LC_MESSAGES/messages.po +++ b/src/iac_code/i18n/locales/es/LC_MESSAGES/messages.po @@ -2959,6 +2959,63 @@ msgstr "Despliegue de ROS" msgid "InfraGuard scan" msgstr "Escaneo de InfraGuard" +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "ECS instance" +msgstr "instancia ECS" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "ECS instance group" +msgstr "grupo de instancias ECS" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "Elastic IP address" +msgstr "dirección IP elástica" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "SLB load balancer" +msgstr "balanceador de carga SLB" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "NAT gateway" +msgstr "puerta de enlace NAT" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "Shared bandwidth package" +msgstr "paquete de ancho de banda compartido" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "Database instance" +msgstr "instancia de base de datos" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "VPC" +msgstr "VPC" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "VSwitch" +msgstr "VSwitch" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "Security group" +msgstr "grupo de seguridad" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "YAML parse error" +msgstr "Error al analizar YAML" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "related resource" +msgstr "recurso relacionado" + +#: src/iac_code/pipeline/engine/architecture_graph.py +#: src/iac_code/ui/components/candidate_selection.py +msgid "Architecture overview" +msgstr "Resumen de arquitectura" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "Show the complete architecture diagram." +msgstr "Mostrar el diagrama de arquitectura completo." + #: src/iac_code/pipeline/engine/ask_user_question_tool.py msgid "" "Pipeline-only tool that asks the user to choose an option or type " @@ -3609,50 +3666,6 @@ msgstr "código de salida {returncode}" msgid "{command} exited with {returncode}: {body}" msgstr "{command} terminó con {returncode}: {body}" -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "ECS instance" -msgstr "Instancia ECS" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "ECS instance group" -msgstr "Grupo de instancias ECS" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "Elastic IP address" -msgstr "Dirección IP elástica" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "SLB load balancer" -msgstr "Balanceador de carga SLB" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "NAT gateway" -msgstr "Puerta de enlace NAT" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "Shared bandwidth package" -msgstr "Paquete de ancho de banda compartido" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "Database instance" -msgstr "Instancia de base de datos" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "VPC" -msgstr "VPC" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "VSwitch" -msgstr "VSwitch" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "Security group" -msgstr "Grupo de seguridad" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "YAML parse error" -msgstr "Error al analizar YAML" - #: src/iac_code/pipeline/engine/show_diagram_tool.py msgid "" "Read a ROS template YAML file and generate an architecture diagram. Pass " @@ -3684,11 +3697,34 @@ msgstr "" "Índice de candidato basado en cero en evaluated_candidates; se usa para " "distinguir nombres duplicados" +#: src/iac_code/pipeline/engine/show_diagram_tool.py +msgid "" +"Use facts to emit an immediate draft diagram and internally optimize it " +"with the LLM; use render to emit a diagram from an explicit " +"semantic_plan." +msgstr "" +"Usa facts para emitir de inmediato un borrador del diagrama y optimizarlo" +" internamente con el LLM; usa render para emitir un diagrama desde un " +"semantic_plan explícito." + +#: src/iac_code/pipeline/engine/show_diagram_tool.py +msgid "" +"Optional LLM-generated semantic graph plan. Edges must reference visible " +"node ids from a prior facts response." +msgstr "" +"Plan de grafo semántico opcional generado por el LLM. Las aristas deben " +"referenciar IDs de nodos visibles de una respuesta facts previa." + #: src/iac_code/pipeline/engine/show_diagram_tool.py #, python-brace-format msgid "Template file does not exist: {file_path}" msgstr "El archivo de plantilla no existe: {file_path}" +#: src/iac_code/pipeline/engine/show_diagram_tool.py +#, python-brace-format +msgid "Generated and optimized the architecture diagram for \"{candidate_name}\"." +msgstr "Se generó y optimizó el diagrama de arquitectura de \"{candidate_name}\"." + #: src/iac_code/pipeline/engine/show_diagram_tool.py #, python-brace-format msgid "Generated the architecture diagram for \"{candidate_name}\"." @@ -6082,6 +6118,10 @@ msgstr "Desplázate hacia arriba para ver más" msgid "Scroll down to view more" msgstr "Desplázate hacia abajo para ver más" +#: src/iac_code/ui/components/candidate_selection.py +msgid "架构图优化中..." +msgstr "Optimizando diagrama de arquitectura..." + #: src/iac_code/ui/components/candidate_selection.py msgid "Loading architecture diagram..." msgstr "Cargando diagrama de arquitectura..." @@ -6090,6 +6130,11 @@ msgstr "Cargando diagrama de arquitectura..." msgid "Loading candidate details..." msgstr "Cargando detalles del candidato..." +#: src/iac_code/ui/components/candidate_selection.py +#, python-brace-format +msgid "Diagram {index}" +msgstr "Diagrama {index}" + #: src/iac_code/ui/components/candidate_selection.py msgid "" "Press number keys to select a candidate, Enter to confirm | ← → switch " @@ -6113,6 +6158,10 @@ msgstr " | 1-{count} saltar directamente" msgid "↑ ↓ scroll" msgstr "↑ ↓ desplazar" +#: src/iac_code/ui/components/candidate_selection.py +msgid "switch diagrams" +msgstr "cambiar diagramas" + #: src/iac_code/ui/components/fuzzy_picker.py msgid "No matches found" msgstr "No se encontraron coincidencias" @@ -6732,3 +6781,33 @@ msgstr "Se rechazó abrir un archivo no regular: {path}" #~ msgid "feature" #~ msgstr "función" +#~ msgid "ECS instance" +#~ msgstr "Instancia ECS" + +#~ msgid "ECS instance group" +#~ msgstr "Grupo de instancias ECS" + +#~ msgid "Elastic IP address" +#~ msgstr "Dirección IP elástica" + +#~ msgid "SLB load balancer" +#~ msgstr "Balanceador de carga SLB" + +#~ msgid "NAT gateway" +#~ msgstr "Puerta de enlace NAT" + +#~ msgid "Shared bandwidth package" +#~ msgstr "Paquete de ancho de banda compartido" + +#~ msgid "Database instance" +#~ msgstr "Instancia de base de datos" + +#~ msgid "VPC" +#~ msgstr "VPC" + +#~ msgid "VSwitch" +#~ msgstr "VSwitch" + +#~ msgid "Security group" +#~ msgstr "Grupo de seguridad" + diff --git a/src/iac_code/i18n/locales/fr/LC_MESSAGES/messages.po b/src/iac_code/i18n/locales/fr/LC_MESSAGES/messages.po index 59d858b8..4617b6a7 100644 --- a/src/iac_code/i18n/locales/fr/LC_MESSAGES/messages.po +++ b/src/iac_code/i18n/locales/fr/LC_MESSAGES/messages.po @@ -2966,6 +2966,63 @@ msgstr "Déploiement ROS" msgid "InfraGuard scan" msgstr "Analyse InfraGuard" +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "ECS instance" +msgstr "instance ECS" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "ECS instance group" +msgstr "groupe d’instances ECS" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "Elastic IP address" +msgstr "adresse IP élastique" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "SLB load balancer" +msgstr "équilibreur de charge SLB" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "NAT gateway" +msgstr "passerelle NAT" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "Shared bandwidth package" +msgstr "package de bande passante partagée" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "Database instance" +msgstr "instance de base de données" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "VPC" +msgstr "VPC" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "VSwitch" +msgstr "VSwitch" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "Security group" +msgstr "groupe de sécurité" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "YAML parse error" +msgstr "Erreur d’analyse YAML" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "related resource" +msgstr "ressource associée" + +#: src/iac_code/pipeline/engine/architecture_graph.py +#: src/iac_code/ui/components/candidate_selection.py +msgid "Architecture overview" +msgstr "Vue d’ensemble de l’architecture" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "Show the complete architecture diagram." +msgstr "Afficher le diagramme d’architecture complet." + #: src/iac_code/pipeline/engine/ask_user_question_tool.py msgid "" "Pipeline-only tool that asks the user to choose an option or type " @@ -3620,50 +3677,6 @@ msgstr "code de sortie {returncode}" msgid "{command} exited with {returncode}: {body}" msgstr "{command} s’est terminé avec {returncode} : {body}" -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "ECS instance" -msgstr "Instance ECS" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "ECS instance group" -msgstr "Groupe d’instances ECS" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "Elastic IP address" -msgstr "Adresse IP élastique" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "SLB load balancer" -msgstr "Équilibreur de charge SLB" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "NAT gateway" -msgstr "Passerelle NAT" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "Shared bandwidth package" -msgstr "Forfait de bande passante partagée" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "Database instance" -msgstr "Instance de base de données" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "VPC" -msgstr "VPC" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "VSwitch" -msgstr "VSwitch" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "Security group" -msgstr "Groupe de sécurité" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "YAML parse error" -msgstr "Erreur d’analyse YAML" - #: src/iac_code/pipeline/engine/show_diagram_tool.py msgid "" "Read a ROS template YAML file and generate an architecture diagram. Pass " @@ -3695,11 +3708,35 @@ msgstr "" "Index de candidat à base zéro dans evaluated_candidates ; utilisé pour " "distinguer les noms en double" +#: src/iac_code/pipeline/engine/show_diagram_tool.py +msgid "" +"Use facts to emit an immediate draft diagram and internally optimize it " +"with the LLM; use render to emit a diagram from an explicit " +"semantic_plan." +msgstr "" +"Utilisez facts pour émettre immédiatement un brouillon du diagramme et " +"l’optimiser en interne avec le LLM ; utilisez render pour émettre un " +"diagramme à partir d’un semantic_plan explicite." + +#: src/iac_code/pipeline/engine/show_diagram_tool.py +msgid "" +"Optional LLM-generated semantic graph plan. Edges must reference visible " +"node ids from a prior facts response." +msgstr "" +"Plan de graphe sémantique facultatif généré par le LLM. Les arêtes " +"doivent référencer des ID de nœuds visibles d’une réponse facts " +"précédente." + #: src/iac_code/pipeline/engine/show_diagram_tool.py #, python-brace-format msgid "Template file does not exist: {file_path}" msgstr "Le fichier de modèle n’existe pas : {file_path}" +#: src/iac_code/pipeline/engine/show_diagram_tool.py +#, python-brace-format +msgid "Generated and optimized the architecture diagram for \"{candidate_name}\"." +msgstr "Diagramme d’architecture généré et optimisé pour « {candidate_name} »." + #: src/iac_code/pipeline/engine/show_diagram_tool.py #, python-brace-format msgid "Generated the architecture diagram for \"{candidate_name}\"." @@ -6105,6 +6142,10 @@ msgstr "Faites défiler vers le haut pour voir plus" msgid "Scroll down to view more" msgstr "Faites défiler vers le bas pour voir plus" +#: src/iac_code/ui/components/candidate_selection.py +msgid "架构图优化中..." +msgstr "Optimisation du diagramme d’architecture..." + #: src/iac_code/ui/components/candidate_selection.py msgid "Loading architecture diagram..." msgstr "Chargement du diagramme d’architecture..." @@ -6113,6 +6154,11 @@ msgstr "Chargement du diagramme d’architecture..." msgid "Loading candidate details..." msgstr "Chargement des détails du candidat..." +#: src/iac_code/ui/components/candidate_selection.py +#, python-brace-format +msgid "Diagram {index}" +msgstr "Diagramme {index}" + #: src/iac_code/ui/components/candidate_selection.py msgid "" "Press number keys to select a candidate, Enter to confirm | ← → switch " @@ -6136,6 +6182,10 @@ msgstr " | 1-{count} accéder directement" msgid "↑ ↓ scroll" msgstr "↑ ↓ faire défiler" +#: src/iac_code/ui/components/candidate_selection.py +msgid "switch diagrams" +msgstr "changer de diagramme" + #: src/iac_code/ui/components/fuzzy_picker.py msgid "No matches found" msgstr "Aucune correspondance" @@ -6752,3 +6802,33 @@ msgstr "Refus d’ouvrir un fichier non ordinaire : {path}" #~ msgid "feature" #~ msgstr "fonctionnalité" +#~ msgid "ECS instance" +#~ msgstr "Instance ECS" + +#~ msgid "ECS instance group" +#~ msgstr "Groupe d’instances ECS" + +#~ msgid "Elastic IP address" +#~ msgstr "Adresse IP élastique" + +#~ msgid "SLB load balancer" +#~ msgstr "Équilibreur de charge SLB" + +#~ msgid "NAT gateway" +#~ msgstr "Passerelle NAT" + +#~ msgid "Shared bandwidth package" +#~ msgstr "Forfait de bande passante partagée" + +#~ msgid "Database instance" +#~ msgstr "Instance de base de données" + +#~ msgid "VPC" +#~ msgstr "VPC" + +#~ msgid "VSwitch" +#~ msgstr "VSwitch" + +#~ msgid "Security group" +#~ msgstr "Groupe de sécurité" + diff --git a/src/iac_code/i18n/locales/ja/LC_MESSAGES/messages.po b/src/iac_code/i18n/locales/ja/LC_MESSAGES/messages.po index 095b97a3..de1aa986 100644 --- a/src/iac_code/i18n/locales/ja/LC_MESSAGES/messages.po +++ b/src/iac_code/i18n/locales/ja/LC_MESSAGES/messages.po @@ -2849,6 +2849,63 @@ msgstr "ROS デプロイ" msgid "InfraGuard scan" msgstr "InfraGuard スキャン" +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "ECS instance" +msgstr "ECS インスタンス" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "ECS instance group" +msgstr "ECS インスタンスグループ" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "Elastic IP address" +msgstr "Elastic IP アドレス" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "SLB load balancer" +msgstr "SLB ロードバランサー" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "NAT gateway" +msgstr "NAT ゲートウェイ" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "Shared bandwidth package" +msgstr "共有帯域幅パッケージ" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "Database instance" +msgstr "データベースインスタンス" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "VPC" +msgstr "VPC" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "VSwitch" +msgstr "VSwitch" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "Security group" +msgstr "セキュリティグループ" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "YAML parse error" +msgstr "YAML 解析エラー" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "related resource" +msgstr "関連リソース" + +#: src/iac_code/pipeline/engine/architecture_graph.py +#: src/iac_code/ui/components/candidate_selection.py +msgid "Architecture overview" +msgstr "アーキテクチャ概要" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "Show the complete architecture diagram." +msgstr "完全なアーキテクチャ図を表示します。" + #: src/iac_code/pipeline/engine/ask_user_question_tool.py msgid "" "Pipeline-only tool that asks the user to choose an option or type " @@ -3422,50 +3479,6 @@ msgstr "終了コード {returncode}" msgid "{command} exited with {returncode}: {body}" msgstr "{command} は {returncode} で終了しました: {body}" -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "ECS instance" -msgstr "ECS インスタンス" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "ECS instance group" -msgstr "ECS インスタンスグループ" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "Elastic IP address" -msgstr "Elastic IP アドレス" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "SLB load balancer" -msgstr "SLB ロードバランサー" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "NAT gateway" -msgstr "NAT ゲートウェイ" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "Shared bandwidth package" -msgstr "共有帯域幅パッケージ" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "Database instance" -msgstr "データベースインスタンス" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "VPC" -msgstr "VPC" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "VSwitch" -msgstr "VSwitch" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "Security group" -msgstr "セキュリティグループ" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "YAML parse error" -msgstr "YAML 解析エラー" - #: src/iac_code/pipeline/engine/show_diagram_tool.py msgid "" "Read a ROS template YAML file and generate an architecture diagram. Pass " @@ -3492,11 +3505,31 @@ msgid "" "duplicate names" msgstr "evaluated_candidates 内の 0 始まりの候補インデックス。重複名の区別に使用します" +#: src/iac_code/pipeline/engine/show_diagram_tool.py +msgid "" +"Use facts to emit an immediate draft diagram and internally optimize it " +"with the LLM; use render to emit a diagram from an explicit " +"semantic_plan." +msgstr "" +"facts を使うと即時にドラフト図を出力し、ツール内部で LLM により最適化します。render を使うと明示的な semantic_plan" +" から図を出力します。" + +#: src/iac_code/pipeline/engine/show_diagram_tool.py +msgid "" +"Optional LLM-generated semantic graph plan. Edges must reference visible " +"node ids from a prior facts response." +msgstr "任意の LLM 生成セマンティックグラフ計画です。エッジは以前の facts 応答に含まれる表示ノード ID を参照する必要があります。" + #: src/iac_code/pipeline/engine/show_diagram_tool.py #, python-brace-format msgid "Template file does not exist: {file_path}" msgstr "テンプレートファイルが存在しません: {file_path}" +#: src/iac_code/pipeline/engine/show_diagram_tool.py +#, python-brace-format +msgid "Generated and optimized the architecture diagram for \"{candidate_name}\"." +msgstr "「{candidate_name}」のアーキテクチャ図を生成して最適化しました。" + #: src/iac_code/pipeline/engine/show_diagram_tool.py #, python-brace-format msgid "Generated the architecture diagram for \"{candidate_name}\"." @@ -5790,6 +5823,10 @@ msgstr "上にスクロールしてさらに表示" msgid "Scroll down to view more" msgstr "下にスクロールしてさらに表示" +#: src/iac_code/ui/components/candidate_selection.py +msgid "架构图优化中..." +msgstr "アーキテクチャ図を最適化中..." + #: src/iac_code/ui/components/candidate_selection.py msgid "Loading architecture diagram..." msgstr "アーキテクチャ図を読み込み中..." @@ -5798,6 +5835,11 @@ msgstr "アーキテクチャ図を読み込み中..." msgid "Loading candidate details..." msgstr "候補の詳細を読み込み中..." +#: src/iac_code/ui/components/candidate_selection.py +#, python-brace-format +msgid "Diagram {index}" +msgstr "図 {index}" + #: src/iac_code/ui/components/candidate_selection.py msgid "" "Press number keys to select a candidate, Enter to confirm | ← → switch " @@ -5819,6 +5861,10 @@ msgstr " | 1-{count} で直接移動" msgid "↑ ↓ scroll" msgstr "↑ ↓ スクロール" +#: src/iac_code/ui/components/candidate_selection.py +msgid "switch diagrams" +msgstr "図を切り替え" + #: src/iac_code/ui/components/fuzzy_picker.py msgid "No matches found" msgstr "一致する項目がありません" @@ -6377,3 +6423,33 @@ msgstr "通常ファイルではないファイルを開くことを拒否しま #~ msgid "feature" #~ msgstr "機能" +#~ msgid "ECS instance" +#~ msgstr "ECS インスタンス" + +#~ msgid "ECS instance group" +#~ msgstr "ECS インスタンスグループ" + +#~ msgid "Elastic IP address" +#~ msgstr "Elastic IP アドレス" + +#~ msgid "SLB load balancer" +#~ msgstr "SLB ロードバランサー" + +#~ msgid "NAT gateway" +#~ msgstr "NAT ゲートウェイ" + +#~ msgid "Shared bandwidth package" +#~ msgstr "共有帯域幅パッケージ" + +#~ msgid "Database instance" +#~ msgstr "データベースインスタンス" + +#~ msgid "VPC" +#~ msgstr "VPC" + +#~ msgid "VSwitch" +#~ msgstr "VSwitch" + +#~ msgid "Security group" +#~ msgstr "セキュリティグループ" + diff --git a/src/iac_code/i18n/locales/pt/LC_MESSAGES/messages.po b/src/iac_code/i18n/locales/pt/LC_MESSAGES/messages.po index d3b288ce..1cb4942a 100644 --- a/src/iac_code/i18n/locales/pt/LC_MESSAGES/messages.po +++ b/src/iac_code/i18n/locales/pt/LC_MESSAGES/messages.po @@ -2942,6 +2942,63 @@ msgstr "Implantação ROS" msgid "InfraGuard scan" msgstr "Varredura InfraGuard" +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "ECS instance" +msgstr "instância ECS" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "ECS instance group" +msgstr "grupo de instâncias ECS" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "Elastic IP address" +msgstr "endereço IP elástico" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "SLB load balancer" +msgstr "balanceador de carga SLB" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "NAT gateway" +msgstr "gateway NAT" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "Shared bandwidth package" +msgstr "pacote de largura de banda compartilhada" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "Database instance" +msgstr "instância de banco de dados" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "VPC" +msgstr "VPC" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "VSwitch" +msgstr "VSwitch" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "Security group" +msgstr "grupo de segurança" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "YAML parse error" +msgstr "Erro ao analisar YAML" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "related resource" +msgstr "recurso relacionado" + +#: src/iac_code/pipeline/engine/architecture_graph.py +#: src/iac_code/ui/components/candidate_selection.py +msgid "Architecture overview" +msgstr "Visão geral da arquitetura" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "Show the complete architecture diagram." +msgstr "Mostrar o diagrama de arquitetura completo." + #: src/iac_code/pipeline/engine/ask_user_question_tool.py msgid "" "Pipeline-only tool that asks the user to choose an option or type " @@ -3582,50 +3639,6 @@ msgstr "código de saída {returncode}" msgid "{command} exited with {returncode}: {body}" msgstr "{command} saiu com {returncode}: {body}" -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "ECS instance" -msgstr "Instância ECS" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "ECS instance group" -msgstr "Grupo de instâncias ECS" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "Elastic IP address" -msgstr "Endereço IP elástico" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "SLB load balancer" -msgstr "Balanceador de carga SLB" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "NAT gateway" -msgstr "Gateway NAT" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "Shared bandwidth package" -msgstr "Pacote de largura de banda compartilhada" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "Database instance" -msgstr "Instância de banco de dados" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "VPC" -msgstr "VPC" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "VSwitch" -msgstr "VSwitch" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "Security group" -msgstr "Grupo de segurança" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "YAML parse error" -msgstr "Erro ao analisar YAML" - #: src/iac_code/pipeline/engine/show_diagram_tool.py msgid "" "Read a ROS template YAML file and generate an architecture diagram. Pass " @@ -3657,11 +3670,34 @@ msgstr "" "Índice de candidato baseado em zero em evaluated_candidates; usado para " "distinguir nomes duplicados" +#: src/iac_code/pipeline/engine/show_diagram_tool.py +msgid "" +"Use facts to emit an immediate draft diagram and internally optimize it " +"with the LLM; use render to emit a diagram from an explicit " +"semantic_plan." +msgstr "" +"Use facts para emitir imediatamente um rascunho do diagrama e otimizá-lo " +"internamente com o LLM; use render para emitir um diagrama a partir de um" +" semantic_plan explícito." + +#: src/iac_code/pipeline/engine/show_diagram_tool.py +msgid "" +"Optional LLM-generated semantic graph plan. Edges must reference visible " +"node ids from a prior facts response." +msgstr "" +"Plano de grafo semântico opcional gerado pelo LLM. As arestas devem " +"referenciar IDs de nós visíveis de uma resposta facts anterior." + #: src/iac_code/pipeline/engine/show_diagram_tool.py #, python-brace-format msgid "Template file does not exist: {file_path}" msgstr "O arquivo de template não existe: {file_path}" +#: src/iac_code/pipeline/engine/show_diagram_tool.py +#, python-brace-format +msgid "Generated and optimized the architecture diagram for \"{candidate_name}\"." +msgstr "Diagrama de arquitetura de \"{candidate_name}\" gerado e otimizado." + #: src/iac_code/pipeline/engine/show_diagram_tool.py #, python-brace-format msgid "Generated the architecture diagram for \"{candidate_name}\"." @@ -6035,6 +6071,10 @@ msgstr "Role para cima para ver mais" msgid "Scroll down to view more" msgstr "Role para baixo para ver mais" +#: src/iac_code/ui/components/candidate_selection.py +msgid "架构图优化中..." +msgstr "Otimizando diagrama de arquitetura..." + #: src/iac_code/ui/components/candidate_selection.py msgid "Loading architecture diagram..." msgstr "Carregando diagrama de arquitetura..." @@ -6043,6 +6083,11 @@ msgstr "Carregando diagrama de arquitetura..." msgid "Loading candidate details..." msgstr "Carregando detalhes do candidato..." +#: src/iac_code/ui/components/candidate_selection.py +#, python-brace-format +msgid "Diagram {index}" +msgstr "Diagrama {index}" + #: src/iac_code/ui/components/candidate_selection.py msgid "" "Press number keys to select a candidate, Enter to confirm | ← → switch " @@ -6066,6 +6111,10 @@ msgstr " | 1-{count} ir diretamente" msgid "↑ ↓ scroll" msgstr "↑ ↓ rolar" +#: src/iac_code/ui/components/candidate_selection.py +msgid "switch diagrams" +msgstr "alternar diagramas" + #: src/iac_code/ui/components/fuzzy_picker.py msgid "No matches found" msgstr "Nenhuma correspondência" @@ -6671,3 +6720,33 @@ msgstr "Recusado abrir arquivo não regular: {path}" #~ msgid "feature" #~ msgstr "recurso" +#~ msgid "ECS instance" +#~ msgstr "Instância ECS" + +#~ msgid "ECS instance group" +#~ msgstr "Grupo de instâncias ECS" + +#~ msgid "Elastic IP address" +#~ msgstr "Endereço IP elástico" + +#~ msgid "SLB load balancer" +#~ msgstr "Balanceador de carga SLB" + +#~ msgid "NAT gateway" +#~ msgstr "Gateway NAT" + +#~ msgid "Shared bandwidth package" +#~ msgstr "Pacote de largura de banda compartilhada" + +#~ msgid "Database instance" +#~ msgstr "Instância de banco de dados" + +#~ msgid "VPC" +#~ msgstr "VPC" + +#~ msgid "VSwitch" +#~ msgstr "VSwitch" + +#~ msgid "Security group" +#~ msgstr "Grupo de segurança" + diff --git a/src/iac_code/i18n/locales/zh/LC_MESSAGES/messages.po b/src/iac_code/i18n/locales/zh/LC_MESSAGES/messages.po index 35654bb6..723d3fbb 100644 --- a/src/iac_code/i18n/locales/zh/LC_MESSAGES/messages.po +++ b/src/iac_code/i18n/locales/zh/LC_MESSAGES/messages.po @@ -2825,6 +2825,63 @@ msgstr "ROS 部署" msgid "InfraGuard scan" msgstr "InfraGuard 扫描" +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "ECS instance" +msgstr "ECS 实例" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "ECS instance group" +msgstr "ECS 实例组" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "Elastic IP address" +msgstr "弹性公网 IP" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "SLB load balancer" +msgstr "SLB 负载均衡" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "NAT gateway" +msgstr "NAT 网关" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "Shared bandwidth package" +msgstr "共享带宽包" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "Database instance" +msgstr "数据库实例" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "VPC" +msgstr "专有网络 VPC" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "VSwitch" +msgstr "交换机" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "Security group" +msgstr "安全组" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "YAML parse error" +msgstr "YAML 解析错误" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "related resource" +msgstr "相关资源" + +#: src/iac_code/pipeline/engine/architecture_graph.py +#: src/iac_code/ui/components/candidate_selection.py +msgid "Architecture overview" +msgstr "架构概览" + +#: src/iac_code/pipeline/engine/architecture_graph.py +msgid "Show the complete architecture diagram." +msgstr "显示完整架构图。" + #: src/iac_code/pipeline/engine/ask_user_question_tool.py msgid "" "Pipeline-only tool that asks the user to choose an option or type " @@ -3375,50 +3432,6 @@ msgstr "退出码 {returncode}" msgid "{command} exited with {returncode}: {body}" msgstr "{command} 退出，返回码 {returncode}：{body}" -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "ECS instance" -msgstr "ECS 实例" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "ECS instance group" -msgstr "ECS 实例组" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "Elastic IP address" -msgstr "弹性公网 IP" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "SLB load balancer" -msgstr "SLB 负载均衡" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "NAT gateway" -msgstr "NAT 网关" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "Shared bandwidth package" -msgstr "共享带宽包" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "Database instance" -msgstr "数据库实例" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "VPC" -msgstr "专有网络 VPC" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "VSwitch" -msgstr "交换机" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "Security group" -msgstr "安全组" - -#: src/iac_code/pipeline/engine/show_diagram_tool.py -msgid "YAML parse error" -msgstr "YAML 解析错误" - #: src/iac_code/pipeline/engine/show_diagram_tool.py msgid "" "Read a ROS template YAML file and generate an architecture diagram. Pass " @@ -3443,11 +3456,29 @@ msgid "" "duplicate names" msgstr "候选方案在 evaluated_candidates 中的 0 基下标；用于区分重名方案" +#: src/iac_code/pipeline/engine/show_diagram_tool.py +msgid "" +"Use facts to emit an immediate draft diagram and internally optimize it " +"with the LLM; use render to emit a diagram from an explicit " +"semantic_plan." +msgstr "使用 facts 立即发出草稿架构图，并由 LLM 在工具内部优化；使用 render 根据显式 semantic_plan 发出架构图。" + +#: src/iac_code/pipeline/engine/show_diagram_tool.py +msgid "" +"Optional LLM-generated semantic graph plan. Edges must reference visible " +"node ids from a prior facts response." +msgstr "可选的 LLM 生成语义图计划。边必须引用前一次 facts 响应中的可见节点 ID。" + #: src/iac_code/pipeline/engine/show_diagram_tool.py #, python-brace-format msgid "Template file does not exist: {file_path}" msgstr "模板文件不存在: {file_path}" +#: src/iac_code/pipeline/engine/show_diagram_tool.py +#, python-brace-format +msgid "Generated and optimized the architecture diagram for \"{candidate_name}\"." +msgstr "已生成并优化“{candidate_name}”的架构图。" + #: src/iac_code/pipeline/engine/show_diagram_tool.py #, python-brace-format msgid "Generated the architecture diagram for \"{candidate_name}\"." @@ -5717,6 +5748,10 @@ msgstr "向上滚动查看更多" msgid "Scroll down to view more" msgstr "向下滚动查看更多" +#: src/iac_code/ui/components/candidate_selection.py +msgid "架构图优化中..." +msgstr "架构图优化中..." + #: src/iac_code/ui/components/candidate_selection.py msgid "Loading architecture diagram..." msgstr "架构图加载中..." @@ -5725,6 +5760,11 @@ msgstr "架构图加载中..." msgid "Loading candidate details..." msgstr "方案详情加载中..." +#: src/iac_code/ui/components/candidate_selection.py +#, python-brace-format +msgid "Diagram {index}" +msgstr "架构图 {index}" + #: src/iac_code/ui/components/candidate_selection.py msgid "" "Press number keys to select a candidate, Enter to confirm | ← → switch " @@ -5746,6 +5786,10 @@ msgstr " | 1-{count} 直接跳转" msgid "↑ ↓ scroll" msgstr "↑ ↓ 滚动" +#: src/iac_code/ui/components/candidate_selection.py +msgid "switch diagrams" +msgstr "切换架构图" + #: src/iac_code/ui/components/fuzzy_picker.py msgid "No matches found" msgstr "未找到匹配项" @@ -6282,3 +6326,33 @@ msgstr "拒绝打开非常规文件：{path}" #~ msgid "feature" #~ msgstr "功能" +#~ msgid "ECS instance" +#~ msgstr "ECS 实例" + +#~ msgid "ECS instance group" +#~ msgstr "ECS 实例组" + +#~ msgid "Elastic IP address" +#~ msgstr "弹性公网 IP" + +#~ msgid "SLB load balancer" +#~ msgstr "SLB 负载均衡" + +#~ msgid "NAT gateway" +#~ msgstr "NAT 网关" + +#~ msgid "Shared bandwidth package" +#~ msgstr "共享带宽包" + +#~ msgid "Database instance" +#~ msgstr "数据库实例" + +#~ msgid "VPC" +#~ msgstr "专有网络 VPC" + +#~ msgid "VSwitch" +#~ msgstr "交换机" + +#~ msgid "Security group" +#~ msgstr "安全组" + diff --git a/src/iac_code/pipeline/engine/architecture_graph.py b/src/iac_code/pipeline/engine/architecture_graph.py new file mode 100644 index 00000000..244f4cb3 --- /dev/null +++ b/src/iac_code/pipeline/engine/architecture_graph.py @@ -0,0 +1,4241 @@ +"""Metadata-backed ROS template to Mermaid architecture graph rendering.""" + +from __future__ import annotations + +import re +from collections import Counter +from dataclasses import dataclass, replace +from typing import Any, cast + +import yaml + +from iac_code.i18n import _, get_current_language +from iac_code.pipeline.engine.architecture_meta import ArchitectureMetaRepository, RelatedProperty, ResourceMeta +from iac_code.pipeline.engine.architecture_rules import ( + ArchitectureRules, + CompactAttachmentEdge, + CompactBridgeAttachment, + CompactConceptGroup, + CompactOrchestrationAction, + ConceptEdgeRule, + RuleLabel, +) + +COMPACT_MIN_VISIBLE_NODES = 25 +COMPACT_MIN_VISIBLE_ELEMENTS = 25 +COMPACT_MIN_EDGES = 25 +COMPACT_MIN_ROOT_NODES = 8 +COMPACT_MIN_AGGREGATE_COUNT = 3 +COMPACT_MIN_FOLDABLE_NODES = 3 +COMPACT_MIN_VISIBLE_ELEMENTS_FOR_SINGLE_FOLDABLE = 8 +SEMANTIC_FANOUT_COMPACT_THRESHOLD = 2 +LAYER_ATTACHMENT_SUMMARY_TYPE = "CONCEPT::Layer::AttachmentSummary" +VIEW_SUMMARY_GROUP_TYPE = "CONCEPT::View::SummaryGroup" +SEMANTIC_EDGE_KINDS = ("traffic", "dependency", "management", "inferred") +RUNTIME_SEMANTIC_EDGE_KINDS = {"traffic", "dependency", "inferred"} +SEMANTIC_EDGE_STYLES = { + "traffic": "solid_arrow", + "dependency": "solid_arrow", + "management": "dotted_arrow", + "inferred": "dotted_open", +} +ACK_CLUSTER_APPLICATION_TYPE = "ALIYUN::CS::ClusterApplication" +ACK_CLUSTER_HELM_APPLICATION_TYPE = "ALIYUN::CS::ClusterHelmApplication" +ACK_HELM_APPLICATION_TYPES = frozenset( + { + ACK_CLUSTER_HELM_APPLICATION_TYPE, + "MODULE::ACS::ComputeNest::FluxOciHelmDeploy", + } +) +SEMANTIC_COMPUTE_AGGREGATE_TYPES = frozenset( + { + "ALIYUN::ECS::Instance", + "ALIYUN::ECS::InstanceGroup", + } +) +SEMANTIC_COMPUTE_ROLE_TOKENS = ( + "mongodb", + "rabbitmq", + "redis", + "mysql", + "postgresql", + "postgres", + "zookeeper", + "kafka", + "nacos", + "elasticsearch", + "logstash", + "kibana", + "consul", + "etcd", + "jenkins", + "gitlab", +) +KUBERNETES_KIND_ATTACHMENT_LABELS: dict[str, RuleLabel] = { + "AlbConfig": {"en": "ALB ingress config", "zh": "ALB入口配置"}, + "ConfigMap": {"en": "app config", "zh": "应用配置"}, + "CronJob": {"en": "application workload", "zh": "应用工作负载"}, + "DaemonSet": {"en": "application workload", "zh": "应用工作负载"}, + "Deployment": {"en": "application workload", "zh": "应用工作负载"}, + "HorizontalPodAutoscaler": {"en": "HPA autoscaling", "zh": "HPA弹性伸缩"}, + "Ingress": {"en": "Ingress entry", "zh": "Ingress入口"}, + "IngressClass": {"en": "Ingress class", "zh": "IngressClass"}, + "Job": {"en": "application workload", "zh": "应用工作负载"}, + "Namespace": {"en": "namespace", "zh": "命名空间"}, + "PersistentVolumeClaim": {"en": "storage claim", "zh": "存储声明"}, + "Role": {"en": "RBAC permission", "zh": "RBAC权限"}, + "RoleBinding": {"en": "RBAC permission", "zh": "RBAC权限"}, + "Secret": {"en": "app secret", "zh": "应用密钥"}, + "Service": {"en": "service exposure", "zh": "服务暴露"}, + "ServiceAccount": {"en": "service account", "zh": "服务账号"}, + "StatefulSet": {"en": "stateful workload", "zh": "有状态工作负载"}, +} +ACK_APPLICATION_CONCEPT_LABELS: dict[str, RuleLabel] = { + "workload": {"en": "ACK application workload", "zh": "ACK应用工作负载"}, + "service": {"en": "ACK service exposure", "zh": "ACK服务暴露"}, + "ingress": {"en": "ACK ingress routing", "zh": "ACK入口路由"}, + "autoscaler": {"en": "ACK HPA autoscaling", "zh": "ACK HPA弹性伸缩"}, +} +ACK_APPLICATION_CONCEPT_EDGE_LABELS: dict[str, RuleLabel] = { + "ingress_to_service": {"en": "ingress route", "zh": "入口路由"}, + "service_to_workload": {"en": "service forwarding", "zh": "服务转发"}, + "autoscaler_to_workload": {"en": "autoscaling", "zh": "弹性伸缩"}, + "metrics_adapter": {"en": "metrics adapter", "zh": "指标适配"}, + "external_metrics": {"en": "external metrics", "zh": "外部指标"}, + "database_access": {"en": "database access", "zh": "数据库访问"}, + "cache_access": {"en": "cache access", "zh": "缓存访问"}, + "vector_search": {"en": "vector search", "zh": "向量检索"}, + "data_dependency": {"en": "data dependency", "zh": "数据依赖"}, +} +ACK_APPLICATION_CONCEPT_TYPES = { + "workload": "CONCEPT::ACK::ApplicationWorkload", + "service": "CONCEPT::ACK::ServiceExposure", + "ingress": "CONCEPT::ACK::IngressEntry", + "autoscaler": "CONCEPT::ACK::HpaAutoscaling", +} +ACK_APPLICATION_CONCEPT_SUFFIXES = { + "workload": "ApplicationWorkload", + "service": "ServiceExposure", + "ingress": "IngressEntry", + "autoscaler": "HpaAutoscaling", +} +ACK_WORKLOAD_KINDS = frozenset({"CronJob", "DaemonSet", "Deployment", "Job", "StatefulSet"}) +ACK_SERVICE_KINDS = frozenset({"Service"}) +ACK_INGRESS_KINDS = frozenset({"AlbConfig", "Ingress", "IngressClass"}) +ACK_AUTOSCALER_KINDS = frozenset({"HorizontalPodAutoscaler"}) +POLARDB_MIGRATION_TARGET_TYPE = "ALIYUN::POLARDB::DBCluster" +POLARDB_MIGRATION_SOURCE_TYPES = frozenset( + { + "ALIYUN::RDS::DBInstance", + "ALIYUN::RDS::PrepayDBInstance", + } +) +POLARDB_MIGRATION_CREATION_OPTIONS = frozenset({"MigrationFromRDS"}) +POLARDB_MIGRATION_EDGE_LABELS: dict[str, RuleLabel] = { + "migrate_to": {"en": "migrate to", "zh": "迁移到"}, +} + + +def _legacy_rule_label_i18n_markers() -> tuple[str, ...]: + """Keep dynamic architecture rule labels visible to Babel extraction.""" + return ( + _("ECS instance"), + _("ECS instance group"), + _("Elastic IP address"), + _("SLB load balancer"), + _("NAT gateway"), + _("Shared bandwidth package"), + _("Database instance"), + _("VPC"), + _("VSwitch"), + _("Security group"), + ) + + +@dataclass +class TemplateResource: + logical_id: str + resource_type: str + properties: dict[str, Any] + meta: ResourceMeta | None + label: str + + @property + def short_type(self) -> str: + parts = self.resource_type.split("::") + return parts[-1] if parts else self.resource_type + + +@dataclass(frozen=True) +class ResourceRelation: + source_id: str + target_id: str + property_name: str + + +@dataclass(frozen=True) +class GraphEdge: + from_id: str + to_id: str + style: str + label: str | None = None + + +@dataclass(frozen=True) +class ArchitectureRenderResult: + mermaid_source: str + architecture_context: dict[str, Any] + + +@dataclass(frozen=True) +class ArchitectureViewResult: + id: str + title: str + purpose: str + mermaid_source: str + architecture_context: dict[str, Any] + + +@dataclass(frozen=True) +class ArchitectureMultiViewRenderResult: + views: tuple[ArchitectureViewResult, ...] + architecture_context: dict[str, Any] + + +@dataclass(frozen=True) +class ConceptNodeInstance: + node_id: str + label: str + resource_type: str + controller_id: str + source_id: str + via_id: str + runtime_source_id: str + group_id: str | None = None + + +@dataclass(frozen=True) +class ConceptGroupInstance: + group_id: str + label: str + resource_type: str + member_ids: tuple[str, ...] + rewrite_edge_kinds: tuple[str, ...] + parent_id: str | None = None + + +def render_ros_template_mermaid( + template_yaml: str, + *, + semantic_plan: dict[str, Any] | None = None, + meta_repository: ArchitectureMetaRepository | None = None, +) -> str: + return render_ros_template_architecture( + template_yaml, + semantic_plan=semantic_plan, + meta_repository=meta_repository, + ).mermaid_source + + +def render_ros_template_architecture( + template_yaml: str, + *, + semantic_plan: dict[str, Any] | None = None, + meta_repository: ArchitectureMetaRepository | None = None, +) -> ArchitectureRenderResult: + from iac_code.tools.cloud.aliyun.ros_yaml import ros_yaml_load + + try: + doc = ros_yaml_load(template_yaml) + except yaml.YAMLError: + return ArchitectureRenderResult( + mermaid_source="graph TD\n Error[{}]".format(_("YAML parse error")), + architecture_context=_error_architecture_context("yaml_parse_error"), + ) + + if not isinstance(doc, dict): + return ArchitectureRenderResult( + mermaid_source="graph TD", + architecture_context=_error_architecture_context("template_is_not_mapping"), + ) + + template_summary = _template_summary_context(doc) + raw_resources = doc.get("Resources") or {} + if not isinstance(raw_resources, dict) or not raw_resources: + return ArchitectureRenderResult( + mermaid_source="graph TD", + architecture_context=_error_architecture_context("template_has_no_resources"), + ) + + params = doc.get("Parameters") or {} + params = params if isinstance(params, dict) else {} + repo = meta_repository or ArchitectureMetaRepository.load_default() + rules = ArchitectureRules.load_default() + resources = _build_template_resources(raw_resources, repo, rules) + if not resources: + return ArchitectureRenderResult( + mermaid_source="graph TD", + architecture_context=_error_architecture_context("template_has_no_supported_resources"), + ) + + original_layers, original_nodes, auxiliary = _classify_resources(resources, rules) + relations = _extract_relations(resources, rules) + layers = dict(original_layers) + nodes = dict(original_nodes) + edges = _edges_from_auxiliary(auxiliary, relations, rules) + edges.extend(_dependency_edges(nodes, relations, rules)) + edges.extend(_polardb_migration_edges(nodes, relations)) + layer_parent, node_parent = _build_containment(layers, nodes, relations, rules) + layers, nodes, edges, node_parent, compacted, semantic_endpoint_aliases = _compact_graph_if_needed( + layers, nodes, edges, node_parent, auxiliary, relations, rules + ) + if compacted: + layers, layer_parent, nodes, node_parent = _flatten_compact_layers( + layers, layer_parent, nodes, node_parent, relations, rules + ) + concept_nodes: tuple[ConceptNodeInstance, ...] = () + concept_groups: tuple[ConceptGroupInstance, ...] = () + if compacted: + layers, layer_parent, nodes, edges, node_parent, concept_nodes, concept_groups = _add_compact_concept_nodes( + resources, layers, layer_parent, nodes, edges, node_parent, relations, rules + ) + nodes, edges, node_parent = _add_ack_application_concept_nodes(resources, nodes, edges, node_parent, relations) + + nodes, node_label_context = _semantic_node_labels_from_plan(semantic_plan, nodes) + semantic_edges, edge_context = _semantic_edges_from_plan( + semantic_plan, nodes, rules, edges, concept_nodes, concept_groups, semantic_endpoint_aliases + ) + semantic_context = {**node_label_context, **edge_context} + edges = _merge_semantic_edges(edges, semantic_edges) + + architecture_context = _build_architecture_context( + template_summary=template_summary, + resources=resources, + original_layers=original_layers, + original_nodes=original_nodes, + auxiliary=auxiliary, + visible_layers=layers, + visible_nodes=nodes, + relations=relations, + edges=_dedupe_edges(edges), + layer_parent=layer_parent, + node_parent=node_parent, + params=params, + compacted=compacted, + semantic_context=semantic_context, + concept_nodes=concept_nodes, + concept_groups=concept_groups, + rules=rules, + ) + + return ArchitectureRenderResult( + mermaid_source=_render_mermaid(layers, nodes, edges, layer_parent, node_parent, params, rules), + architecture_context=architecture_context, + ) + + +def render_ros_template_architecture_views( + template_yaml: str, + *, + semantic_plan: dict[str, Any] | None = None, + meta_repository: ArchitectureMetaRepository | None = None, +) -> ArchitectureMultiViewRenderResult: + base_result = render_ros_template_architecture( + template_yaml, + semantic_plan=semantic_plan, + meta_repository=meta_repository, + ) + views = _render_views_from_context(base_result.architecture_context, base_result.mermaid_source, semantic_plan) + return ArchitectureMultiViewRenderResult( + views=views, + architecture_context={ + **base_result.architecture_context, + "views": [view.architecture_context for view in views], + }, + ) + + +def _build_template_resources( + raw_resources: dict[str, Any], + repo: ArchitectureMetaRepository, + rules: ArchitectureRules, +) -> dict[str, TemplateResource]: + resources: dict[str, TemplateResource] = {} + for logical_id, raw in raw_resources.items(): + if not isinstance(logical_id, str) or not isinstance(raw, dict): + continue + resource_type = raw.get("Type") + if not isinstance(resource_type, str) or not resource_type: + continue + props = raw.get("Properties") if isinstance(raw.get("Properties"), dict) else {} + meta = repo.get_resource(resource_type) + resources[logical_id] = TemplateResource( + logical_id=logical_id, + resource_type=resource_type, + properties=props, + meta=meta, + label=_resource_label(resource_type, meta, rules), + ) + _disambiguate_labels(resources) + return resources + + +def _template_summary_context(doc: dict[str, Any]) -> dict[str, Any]: + descriptions = _localized_text_map(doc.get("Description")) + description = _select_localized_text(descriptions) + if not description: + return {} + return { + "description": description, + "descriptions": descriptions, + } + + +def _localized_text_map(value: Any) -> dict[str, str]: + if isinstance(value, str): + text = _compact_template_text(value) + return {"default": text} if text else {} + if not isinstance(value, dict): + return {} + result: dict[str, str] = {} + for raw_key, raw_text in value.items(): + if not isinstance(raw_key, str) or not isinstance(raw_text, str): + continue + text = _compact_template_text(raw_text) + if text: + result[raw_key] = text + return result + + +def _select_localized_text(values: dict[str, str]) -> str | None: + if not values: + return None + language = get_current_language() + preferred_keys = { + "zh": ("zh-cn", "zh_CN", "zh", "cn", "default", "en"), + "en": ("en", "en-us", "en_US", "default", "zh-cn", "zh"), + }.get(language, (language, "default", "en", "zh-cn", "zh")) + normalized_values = {key.lower().replace("_", "-"): value for key, value in values.items()} + for key in preferred_keys: + value = values.get(key) or normalized_values.get(key.lower().replace("_", "-")) + if value: + return value + return next(iter(values.values())) + + +def _compact_template_text(value: str, max_chars: int = 1200) -> str: + text = re.sub(r"\s+", " ", value).strip() + if len(text) <= max_chars: + return text + return text[: max_chars - 1].rstrip() + "…" + + +def _resource_label(resource_type: str, meta: ResourceMeta | None, rules: ArchitectureRules) -> str: + legacy_label = rules.legacy_resource_labels.get(resource_type) + if legacy_label is not None: + return _(legacy_label) + meta_label = _localized_meta_label(meta) + if meta_label is not None: + return meta_label + parts = resource_type.split("::") + if len(parts) >= 3: + return f"{parts[1]}::{parts[-1]}" + return resource_type + + +def _localized_meta_label(meta: ResourceMeta | None) -> str | None: + if meta is None: + return None + language = get_current_language() + if language == "zh" and meta.name_zh: + return meta.name_zh + if meta.name_en: + return meta.name_en + return meta.name_zh + + +def _localized_rule_label(value: RuleLabel | None) -> str | None: + if value is None: + return None + if isinstance(value, str): + return _(value) + language = get_current_language() + return value.get(language) or value.get("en") or next(iter(value.values()), None) + + +def _disambiguate_labels(resources: dict[str, TemplateResource]) -> None: + label_counts = Counter(resource.label for resource in resources.values()) + label_seq: Counter[str] = Counter() + for resource in resources.values(): + if label_counts[resource.label] > 1: + label_seq[resource.label] += 1 + resource.label = f"{resource.label} {label_seq[resource.label]}" + + +def _classify_resources( + resources: dict[str, TemplateResource], + rules: ArchitectureRules, +) -> tuple[dict[str, TemplateResource], dict[str, TemplateResource], dict[str, TemplateResource]]: + layers: dict[str, TemplateResource] = {} + nodes: dict[str, TemplateResource] = {} + auxiliary: dict[str, TemplateResource] = {} + layer_types = rules.network_layer_types | _all_containment_layer_types(rules) + for logical_id, resource in resources.items(): + if resource.resource_type in layer_types: + layers[logical_id] = resource + elif _is_auxiliary(resource, rules): + auxiliary[logical_id] = resource + else: + nodes[logical_id] = resource + return layers, nodes, auxiliary + + +def _is_auxiliary(resource: TemplateResource, rules: ArchitectureRules) -> bool: + if resource.meta is not None and resource.meta.main_resource_type is not None: + return True + return resource.short_type in rules.legacy_auxiliary_short_types + + +def _all_containment_layer_types(rules: ArchitectureRules) -> frozenset[str]: + return frozenset( + resource_type for resource_types in rules.containment_layer_types.values() for resource_type in resource_types + ) + + +def _extract_relations(resources: dict[str, TemplateResource], rules: ArchitectureRules) -> list[ResourceRelation]: + relations: list[ResourceRelation] = [] + for source in resources.values(): + related_properties = list(source.meta.related_properties) if source.meta is not None else [] + related_properties.extend(_fallback_related_properties(source, rules)) + related_properties.extend(_supplemental_related_properties(source, rules)) + related_properties = _dedupe_related_properties(related_properties) + for prop in related_properties: + values = _values_at_path(source.properties, prop.path) + if not values and len(prop.path) > 1 and prop.path[0] in source.properties: + values = [source.properties[prop.path[0]]] + for value in values: + for target_id in _extract_resource_refs(value, resources): + target = resources.get(target_id) + if target is None or (prop.targets and target.resource_type not in prop.targets): + continue + relations.append( + ResourceRelation(source_id=source.logical_id, target_id=target_id, property_name=prop.name) + ) + return relations + + +def _fallback_related_properties(source: TemplateResource, rules: ArchitectureRules) -> list[RelatedProperty]: + if source.meta is not None: + known_names = {prop.name for prop in source.meta.related_properties} + else: + known_names = set() + return [ + RelatedProperty(name=name, path=(name,), targets=targets) + for name, targets in rules.fallback_related_properties.items() + if name in source.properties and name not in known_names + ] + + +def _supplemental_related_properties(source: TemplateResource, rules: ArchitectureRules) -> list[RelatedProperty]: + supplemental = rules.supplemental_related_properties.get(source.resource_type, {}) + properties: list[RelatedProperty] = [] + for name, targets in supplemental.items(): + path = tuple(part for part in name.split(".") if part) + if not path or path[0] not in source.properties: + continue + properties.append(RelatedProperty(name=path[-1], path=path, targets=targets)) + return properties + + +def _dedupe_related_properties(related_properties: list[RelatedProperty]) -> list[RelatedProperty]: + deduped: list[RelatedProperty] = [] + seen: set[tuple[str, tuple[str, ...], tuple[str, ...]]] = set() + for prop in related_properties: + key = (prop.name, prop.path, prop.targets) + if key in seen: + continue + seen.add(key) + deduped.append(prop) + return deduped + + +def _values_at_path(value: Any, path: tuple[str, ...]) -> list[Any]: + if not path: + return [value] + if isinstance(value, list): + values: list[Any] = [] + for item in value: + values.extend(_values_at_path(item, path)) + return values + if not isinstance(value, dict): + return [] + key = path[0] + if key not in value: + return [] + return _values_at_path(value[key], path[1:]) + + +def _extract_resource_refs(value: Any, resources: dict[str, TemplateResource]) -> list[str]: + refs: list[str] = [] + if isinstance(value, dict): + ref = value.get("Ref") + if isinstance(ref, str) and ref in resources: + refs.append(ref) + get_att = value.get("Fn::GetAtt") + if isinstance(get_att, list) and get_att and isinstance(get_att[0], str) and get_att[0] in resources: + refs.append(get_att[0]) + elif isinstance(get_att, str): + logical_id = get_att.split(".", 1)[0] + if logical_id in resources: + refs.append(logical_id) + for child in value.values(): + refs.extend(_extract_resource_refs(child, resources)) + elif isinstance(value, list): + for item in value: + refs.extend(_extract_resource_refs(item, resources)) + elif isinstance(value, str): + refs.extend(_extract_template_refs_from_text(value, resources)) + return _dedupe(refs) + + +def _edges_from_auxiliary( + auxiliary: dict[str, TemplateResource], + relations: list[ResourceRelation], + rules: ArchitectureRules, +) -> list[GraphEdge]: + edges: list[GraphEdge] = [] + by_source = _relations_by_source(relations) + for resource in auxiliary.values(): + main_ref = _main_resource_ref(resource, by_source.get(resource.logical_id, [])) + if main_ref is None: + continue + for relation in by_source.get(resource.logical_id, []): + if relation.target_id != main_ref: + edges.append(GraphEdge(main_ref, relation.target_id, rules.edge_styles.auxiliary_relation)) + return _dedupe_edges(edges) + + +def _main_resource_ref(resource: TemplateResource, relations: list[ResourceRelation]) -> str | None: + if resource.meta is None or resource.meta.main_resource_type is None: + return None + main = resource.meta.main_resource_type + for relation in relations: + if relation.property_name == main.ref_property: + return relation.target_id + return None + + +def _dependency_edges( + nodes: dict[str, TemplateResource], + relations: list[ResourceRelation], + rules: ArchitectureRules, +) -> list[GraphEdge]: + node_ids = set(nodes) + edges: list[GraphEdge] = [] + for relation in relations: + if relation.source_id in node_ids and relation.target_id in node_ids: + edges.append(GraphEdge(relation.target_id, relation.source_id, rules.edge_styles.direct_relation)) + return _dedupe_edges(edges) + + +def _polardb_migration_edges( + nodes: dict[str, TemplateResource], + relations: list[ResourceRelation], +) -> list[GraphEdge]: + by_source = _relations_by_source(relations) + edges: list[GraphEdge] = [] + for target in nodes.values(): + if target.resource_type != POLARDB_MIGRATION_TARGET_TYPE: + continue + creation_option = target.properties.get("CreationOption") + if not isinstance(creation_option, str) or creation_option not in POLARDB_MIGRATION_CREATION_OPTIONS: + continue + for relation in by_source.get(target.logical_id, []): + if relation.property_name != "SourceResourceId": + continue + source = nodes.get(relation.target_id) + if source is None or source.resource_type not in POLARDB_MIGRATION_SOURCE_TYPES: + continue + edges.append( + GraphEdge( + from_id=source.logical_id, + to_id=target.logical_id, + style="solid_arrow", + label=_localized_rule_label(POLARDB_MIGRATION_EDGE_LABELS["migrate_to"]), + ) + ) + return _dedupe_edges(edges) + + +def _semantic_edges_from_plan( + semantic_plan: dict[str, Any] | None, + nodes: dict[str, TemplateResource], + rules: ArchitectureRules, + deterministic_edges: list[GraphEdge] | None = None, + concept_nodes: tuple[ConceptNodeInstance, ...] = (), + concept_groups: tuple[ConceptGroupInstance, ...] = (), + endpoint_aliases: dict[str, str] | None = None, +) -> tuple[list[GraphEdge], dict[str, Any]]: + accepted: list[dict[str, str]] = [] + rejected: list[dict[str, str]] = [] + edges: list[GraphEdge] = [] + raw_edges = semantic_plan.get("edges") if isinstance(semantic_plan, dict) else [] + if not isinstance(raw_edges, list): + raw_edges = [] + scaled_runtime_pairs = _scaled_runtime_concept_pairs(raw_edges, concept_nodes) + allowed_endpoint_ids = set(nodes) | {group.group_id for group in concept_groups} + + for raw_edge in raw_edges: + if not isinstance(raw_edge, dict): + continue + from_id = _semantic_edge_endpoint(raw_edge, "from") + to_id = _semantic_edge_endpoint(raw_edge, "to") + if from_id is None or to_id is None: + rejected.append({"from": from_id or "", "to": to_id or "", "reason": "missing endpoint"}) + continue + kind = raw_edge.get("kind") + if not isinstance(kind, str) or kind not in SEMANTIC_EDGE_STYLES: + kind = "inferred" + from_id = (endpoint_aliases or {}).get(from_id, from_id) + to_id = (endpoint_aliases or {}).get(to_id, to_id) + if from_id == to_id: + rejected.append({"from": from_id, "to": to_id, "reason": "covered by folded resource"}) + continue + if _is_covered_by_concept_edge(from_id, to_id, concept_nodes): + rejected.append({"from": from_id, "to": to_id, "reason": "covered by scaled concept"}) + continue + scaled_cover_pair = _scaled_runtime_source_pair( + from_id, to_id, kind, concept_nodes + ) or _scaled_runtime_controller_peer_pair(from_id, to_id, kind, concept_nodes) + if scaled_cover_pair in scaled_runtime_pairs: + rejected.append({"from": from_id, "to": to_id, "reason": "covered by scaled runtime edge"}) + continue + from_id, to_id = _rewrite_semantic_concept_endpoints(from_id, to_id, kind, concept_nodes) + from_id, to_id = _rewrite_semantic_group_endpoints(from_id, to_id, kind, concept_groups) + if _is_covered_by_deterministic_edge(from_id, to_id, deterministic_edges or []): + rejected.append({"from": from_id, "to": to_id, "reason": "covered by deterministic edge"}) + continue + if from_id not in allowed_endpoint_ids or to_id not in allowed_endpoint_ids: + rejected.append({"from": from_id, "to": to_id, "reason": "unknown node"}) + continue + label = _semantic_edge_label(raw_edge) + confidence = raw_edge.get("confidence") + if not isinstance(confidence, str) or confidence not in {"high", "medium", "low"}: + confidence = "medium" + edges.append( + GraphEdge( + from_id=from_id, + to_id=to_id, + style=SEMANTIC_EDGE_STYLES.get(kind, rules.edge_styles.direct_relation), + label=label, + ) + ) + accepted.append( + { + "from": from_id, + "to": to_id, + "kind": kind, + "label": label or "", + "confidence": confidence, + } + ) + + return _dedupe_edges(edges), {"accepted_edges": accepted, "rejected_edges": rejected} + + +def _semantic_node_labels_from_plan( + semantic_plan: dict[str, Any] | None, + nodes: dict[str, TemplateResource], +) -> tuple[dict[str, TemplateResource], dict[str, Any]]: + accepted: list[dict[str, str]] = [] + rejected: list[dict[str, str]] = [] + updated_nodes = dict(nodes) + raw_labels = semantic_plan.get("node_labels") if isinstance(semantic_plan, dict) else [] + if not isinstance(raw_labels, list): + raw_labels = [] + + for raw_label in raw_labels: + if not isinstance(raw_label, dict): + continue + node_id = _semantic_node_label_id(raw_label) + if node_id is None: + rejected.append({"id": "", "reason": "missing node id"}) + continue + if node_id not in updated_nodes: + rejected.append({"id": node_id, "reason": "unknown node"}) + continue + label = _semantic_node_label(raw_label) + if label is None: + rejected.append({"id": node_id, "reason": "missing label"}) + continue + confidence = raw_label.get("confidence") + if not isinstance(confidence, str) or confidence not in {"high", "medium", "low"}: + confidence = "medium" + reason = raw_label.get("reason") + accepted_label = { + "id": node_id, + "label": label, + "confidence": confidence, + } + if isinstance(reason, str) and reason.strip(): + accepted_label["reason"] = " ".join(reason.strip().split())[:80] + accepted.append(accepted_label) + updated_nodes[node_id] = replace( + updated_nodes[node_id], + label=_replace_base_label(updated_nodes[node_id].label, label), + ) + + return updated_nodes, {"accepted_node_labels": accepted, "rejected_node_labels": rejected} + + +def _semantic_node_label_id(raw_label: dict[str, Any]) -> str | None: + value = raw_label.get("id") + if not isinstance(value, str) or not value.strip(): + value = raw_label.get("node_id") + return value.strip() if isinstance(value, str) and value.strip() else None + + +def _semantic_node_label(raw_label: dict[str, Any]) -> str | None: + value = raw_label.get("label") + if not isinstance(value, str): + return None + label = " ".join(value.replace("\n", " ").strip().split()) + if not label: + return None + return label[:32] + + +def _replace_base_label(current_label: str, base_label: str) -> str: + parts = current_label.split("\\n") + return "\\n".join([base_label, *parts[1:]]) + + +def _is_covered_by_concept_edge( + from_id: str, + to_id: str, + concept_nodes: tuple[ConceptNodeInstance, ...], +) -> bool: + return any({from_id, to_id} == {concept.controller_id, concept.source_id} for concept in concept_nodes) + + +def _is_covered_by_deterministic_edge( + from_id: str, + to_id: str, + deterministic_edges: list[GraphEdge], +) -> bool: + for edge in deterministic_edges: + if edge.label is None: + continue + if (edge.from_id, edge.to_id) == (from_id, to_id): + return True + if _is_reverse_of_directional_deterministic_edge(edge, from_id, to_id): + return True + if edge.style == "dotted_open" and {edge.from_id, edge.to_id} == {from_id, to_id}: + return True + return False + + +def _is_reverse_of_directional_deterministic_edge(edge: GraphEdge, from_id: str, to_id: str) -> bool: + return ( + (edge.from_id, edge.to_id) == (to_id, from_id) + and edge.label in {"migrate to", "迁移到"} + and edge.style == "solid_arrow" + ) + + +def _scaled_runtime_concept_pairs( + raw_edges: list[Any], + concept_nodes: tuple[ConceptNodeInstance, ...], +) -> set[frozenset[str]]: + pairs: set[frozenset[str]] = set() + for raw_edge in raw_edges: + if not isinstance(raw_edge, dict): + continue + kind = raw_edge.get("kind") + if not isinstance(kind, str) or kind not in RUNTIME_SEMANTIC_EDGE_KINDS: + continue + from_id = _semantic_edge_endpoint(raw_edge, "from") + to_id = _semantic_edge_endpoint(raw_edge, "to") + if from_id is None or to_id is None: + continue + from_id, to_id = _rewrite_semantic_concept_endpoints(from_id, to_id, kind, concept_nodes) + for concept in concept_nodes: + if from_id == concept.node_id and to_id != concept.runtime_source_id: + pairs.add(frozenset({from_id, to_id})) + if to_id == concept.node_id and from_id != concept.runtime_source_id: + pairs.add(frozenset({from_id, to_id})) + return pairs + + +def _scaled_runtime_source_pair( + from_id: str, + to_id: str, + kind: str, + concept_nodes: tuple[ConceptNodeInstance, ...], +) -> frozenset[str] | None: + if kind not in RUNTIME_SEMANTIC_EDGE_KINDS: + return None + for concept in concept_nodes: + if from_id == concept.runtime_source_id and to_id != concept.node_id: + return frozenset({concept.node_id, to_id}) + if to_id == concept.runtime_source_id and from_id != concept.node_id: + return frozenset({from_id, concept.node_id}) + return None + + +def _scaled_runtime_controller_peer_pair( + from_id: str, + to_id: str, + kind: str, + concept_nodes: tuple[ConceptNodeInstance, ...], +) -> frozenset[str] | None: + if kind in RUNTIME_SEMANTIC_EDGE_KINDS: + return None + for concept in concept_nodes: + if from_id == concept.controller_id and to_id not in {concept.node_id, concept.source_id}: + return frozenset({concept.node_id, to_id}) + if to_id == concept.controller_id and from_id not in {concept.node_id, concept.source_id}: + return frozenset({from_id, concept.node_id}) + return None + + +def _rewrite_semantic_concept_endpoints( + from_id: str, + to_id: str, + kind: str, + concept_nodes: tuple[ConceptNodeInstance, ...], +) -> tuple[str, str]: + if kind not in RUNTIME_SEMANTIC_EDGE_KINDS: + return from_id, to_id + controller_to_concept = {concept.controller_id: concept.node_id for concept in concept_nodes} + if from_id in controller_to_concept and to_id != controller_to_concept[from_id]: + from_id = controller_to_concept[from_id] + if to_id in controller_to_concept and from_id != controller_to_concept[to_id]: + to_id = controller_to_concept[to_id] + return from_id, to_id + + +def _rewrite_semantic_group_endpoints( + from_id: str, + to_id: str, + kind: str, + concept_groups: tuple[ConceptGroupInstance, ...], +) -> tuple[str, str]: + for group in concept_groups: + if kind not in group.rewrite_edge_kinds: + continue + member_ids = set(group.member_ids) + from_is_member = from_id in member_ids + to_is_member = to_id in member_ids + if from_is_member and not to_is_member: + from_id = group.group_id + if to_is_member and not from_is_member: + to_id = group.group_id + return from_id, to_id + + +def _semantic_edge_endpoint(raw_edge: dict[str, Any], key: str) -> str | None: + value = raw_edge.get(key) + if not isinstance(value, str) or not value.strip(): + value = raw_edge.get(f"{key}_id") + return value.strip() if isinstance(value, str) and value.strip() else None + + +def _semantic_edge_label(raw_edge: dict[str, Any]) -> str | None: + value = raw_edge.get("label") + if not isinstance(value, str): + return None + label = _normalize_semantic_edge_label(value) + if not label: + return None + return label[:18] + + +def _normalize_semantic_edge_label(value: str) -> str: + value = re.sub(r"(?i)", "\n", value.strip()).replace("\\n", "\n") + parts = [" ".join(part.strip().split()) for part in value.splitlines()] + parts = [part for part in parts if part] + if not parts: + return "" + if len(parts) == 1: + return parts[0] + return "{}（{}）".format(parts[0], " / ".join(parts[1:])) + + +def _merge_semantic_edges(base_edges: list[GraphEdge], semantic_edges: list[GraphEdge]) -> list[GraphEdge]: + semantic_pairs = {(edge.from_id, edge.to_id) for edge in semantic_edges} + semantic_unordered_pairs = {frozenset((edge.from_id, edge.to_id)) for edge in semantic_edges} + merged = [ + edge + for edge in base_edges + if (edge.from_id, edge.to_id) not in semantic_pairs + and not _is_unlabeled_relation_covered_by_semantic_edge(edge, semantic_unordered_pairs) + ] + merged.extend(semantic_edges) + return _dedupe_edges(merged) + + +def _is_unlabeled_relation_covered_by_semantic_edge( + edge: GraphEdge, + semantic_unordered_pairs: set[frozenset[str]], +) -> bool: + return ( + edge.label is None + and edge.style == "dotted_open" + and frozenset((edge.from_id, edge.to_id)) in semantic_unordered_pairs + ) + + +def _compact_semantic_fanout_edges( + nodes: dict[str, TemplateResource], + semantic_edges: list[GraphEdge], + rules: ArchitectureRules, +) -> tuple[dict[str, TemplateResource], list[GraphEdge], list[dict[str, Any]]]: + grouped_edges: dict[tuple[str, str, str, str], list[GraphEdge]] = {} + for edge in semantic_edges: + target = nodes.get(edge.to_id) + if edge.from_id not in nodes or target is None: + continue + key = (edge.from_id, edge.style, edge.label or "", target.resource_type) + grouped_edges.setdefault(key, []).append(edge) + + compacted_edges: set[GraphEdge] = set() + attachment_labels: dict[str, list[str]] = {} + context: list[dict[str, Any]] = [] + for (source_id, style, label, target_type), group in grouped_edges.items(): + target_ids = tuple(_dedupe([edge.to_id for edge in group])) + if len(target_ids) < SEMANTIC_FANOUT_COMPACT_THRESHOLD: + continue + compacted_edges.update(group) + attachment_label = _semantic_fanout_attachment_label(label, target_ids, nodes, rules) + attachment_labels.setdefault(source_id, []).append(attachment_label) + context.append( + { + "from": source_id, + "targets": list(target_ids), + "style": style, + "label": label, + "target_type": target_type, + "rendered_as": "source_attachment", + "attachment_label": f"{rules.attachment_label_prefix}{attachment_label}", + "reason": "same source fan-out compacted for terminal readability", + } + ) + + if not compacted_edges: + return nodes, semantic_edges, [] + + remaining_edges = [edge for edge in semantic_edges if edge not in compacted_edges] + updated_nodes = _with_attachment_labels( + nodes, + {node_id: tuple(labels) for node_id, labels in attachment_labels.items()}, + rules, + ) + return updated_nodes, remaining_edges, context + + +def _semantic_fanout_attachment_label( + label: str, + target_ids: tuple[str, ...], + nodes: dict[str, TemplateResource], + rules: ArchitectureRules, +) -> str: + base_label = label or _semantic_fanout_target_label(target_ids, nodes, rules) + return f"{base_label} x{len(target_ids)}" + + +def _semantic_fanout_target_label( + target_ids: tuple[str, ...], + nodes: dict[str, TemplateResource], + rules: ArchitectureRules, +) -> str: + target_labels = [_semantic_base_label(nodes[target_id].label) for target_id in target_ids if target_id in nodes] + normalized_labels = {_strip_trailing_sequence(label) for label in target_labels if label} + if len(normalized_labels) == 1: + return next(iter(normalized_labels)) + for target_id in target_ids: + target = nodes.get(target_id) + if target is not None: + return _compact_resource_label(target, rules) + return _("related resource") + + +def _semantic_base_label(label: str) -> str: + return label.split("\\n", 1)[0].strip() + + +def _strip_trailing_sequence(label: str) -> str: + stripped = re.sub(r"[\s_-]+(?:x\s*)?\d+$", "", label.strip(), flags=re.I).strip() + return stripped or label.strip() + + +def _build_architecture_context( + *, + template_summary: dict[str, Any], + resources: dict[str, TemplateResource], + original_layers: dict[str, TemplateResource], + original_nodes: dict[str, TemplateResource], + auxiliary: dict[str, TemplateResource], + visible_layers: dict[str, TemplateResource], + visible_nodes: dict[str, TemplateResource], + relations: list[ResourceRelation], + edges: list[GraphEdge], + layer_parent: dict[str, str], + node_parent: dict[str, str], + params: dict[str, Any], + compacted: bool, + semantic_context: dict[str, Any], + concept_nodes: tuple[ConceptNodeInstance, ...], + concept_groups: tuple[ConceptGroupInstance, ...], + rules: ArchitectureRules, +) -> dict[str, Any]: + resource_roles = _resource_roles(original_layers, original_nodes, auxiliary) + context = { + "version": "1.0", + "compacted": compacted, + "target_language": _target_language_context(), + "resources": [ + { + "id": resource.logical_id, + "label": resource.label, + "type": resource.resource_type, + "role": resource_roles.get(resource_id, "unknown"), + "visible": resource_id in visible_layers or resource_id in visible_nodes, + } + for resource_id, resource in resources.items() + ], + "containers": [ + { + "id": layer_id, + "label": _context_layer_label(layer, params, rules), + "type": layer.resource_type, + "parent": layer_parent.get(layer_id), + } + for layer_id, layer in visible_layers.items() + ], + "visible_nodes": [ + {"id": node.logical_id, "label": node.label, "type": node.resource_type} for node in visible_nodes.values() + ], + "containment": [ + {"resource": node_id, "container": parent_id} + for node_id, parent_id in node_parent.items() + if node_id in visible_nodes and parent_id in visible_layers + ], + "explicit_relations": [ + { + "source": relation.source_id, + "target": relation.target_id, + "property": relation.property_name, + "source_type": resources[relation.source_id].resource_type, + "target_type": resources[relation.target_id].resource_type, + } + for relation in relations + if relation.source_id in resources and relation.target_id in resources + ], + "property_references": _property_reference_context(resources, visible_nodes), + "all_property_references": _all_property_reference_context(resources, visible_nodes), + "route_intents": _route_intent_context(resources), + "orchestration_actions": _orchestration_action_context(resources, visible_nodes, rules), + "node_label_hints": _node_label_hint_context(visible_nodes), + "attachments": _attachment_context(auxiliary, relations, resources), + "network_attachments": _network_attachment_context(resources), + "kubernetes_applications": _ack_application_context(resources, relations), + "concept_nodes": [ + { + "id": concept.node_id, + "label": concept.label, + "type": concept.resource_type, + "controller": concept.controller_id, + "source": concept.source_id, + "via": concept.via_id, + "runtime_source": concept.runtime_source_id, + "group": concept.group_id, + } + for concept in concept_nodes + if concept.node_id in visible_nodes + ], + "concept_groups": [ + { + "id": group.group_id, + "label": group.label, + "type": group.resource_type, + "members": list(group.member_ids), + "parent": group.parent_id, + } + for group in concept_groups + if group.group_id in visible_layers + ], + "visible_edges": [ + { + "from": edge.from_id, + "to": edge.to_id, + "style": edge.style, + "label": edge.label, + } + for edge in edges + if (edge.from_id in visible_nodes or edge.from_id in visible_layers) + and (edge.to_id in visible_nodes or edge.to_id in visible_layers) + ], + "semantic_plan": semantic_context, + "llm_semantic_plan_schema": _llm_semantic_plan_schema(), + "llm_rendering_contract": [ + "Use only ids listed in visible_nodes for semantic_plan.edges endpoints.", + "Use only ids listed in visible_nodes for semantic_plan.node_labels ids.", + "Node labels replace only the main node title; attachment lines are preserved by the renderer.", + "Do not encode VPC/VSwitch/SecurityGroup containment as semantic edges.", + "Use traffic/dependency only for high-confidence runtime relationships.", + "Use management or inferred for configuration, orchestration, or uncertain relationships.", + ( + "For scaled compute concept groups, put inherited application traffic on the group members; " + "the renderer may lift it to the group." + ), + "Use orchestration_actions as intent evidence, but do not render orchestration actions as nodes.", + "Never present inferred edges as explicit template references.", + ], + } + if template_summary: + context["template_summary"] = template_summary + return context + + +def _render_views_from_context( + architecture_context: dict[str, Any], + overview_mermaid_source: str, + semantic_plan: dict[str, Any] | None, +) -> tuple[ArchitectureViewResult, ...]: + raw_views = semantic_plan.get("views") if isinstance(semantic_plan, dict) else None + if not isinstance(raw_views, list) or not raw_views: + return ( + ArchitectureViewResult( + id="overview", + title=_("Architecture overview"), + purpose=_("Show the complete architecture diagram."), + mermaid_source=overview_mermaid_source, + architecture_context={ + "id": "overview", + "title": _("Architecture overview"), + "purpose": _("Show the complete architecture diagram."), + "rendered_as": "full_architecture", + }, + ), + ) + + rules = ArchitectureRules.load_default() + detail_anchor_labels = _semantic_detail_anchor_labels(raw_views) + rendered_views: list[ArchitectureViewResult] = [] + for index, raw_view_value in enumerate(raw_views, start=1): + if not isinstance(raw_view_value, dict): + continue + raw_view = cast("dict[str, Any]", raw_view_value) + rendered = _render_single_view_from_context( + architecture_context, + raw_view, + index, + rules, + detail_anchor_labels, + ) + if rendered is not None: + rendered_views.append(rendered) + + if not rendered_views: + return _render_views_from_context(architecture_context, overview_mermaid_source, None) + return tuple(rendered_views) + + +def _render_single_view_from_context( + architecture_context: dict[str, Any], + raw_view: dict[str, Any], + index: int, + rules: ArchitectureRules, + detail_anchor_labels: dict[str, list[str]], +) -> ArchitectureViewResult | None: + view_id = _semantic_view_id(raw_view, index) + title = _semantic_view_text(raw_view.get("title"), default=view_id) + purpose = _semantic_view_text(raw_view.get("purpose"), default="") + layout = _semantic_view_layout(raw_view, view_id) + anchors = sorted(_semantic_view_anchor_ids(raw_view)) + + nodes_by_id = _context_nodes_by_id(architecture_context) + containers_by_id = _context_containers_by_id(architecture_context) + node_parent = _context_node_parent(architecture_context) + layer_parent = _context_layer_parent(containers_by_id) + group_nodes, group_node_parent = _semantic_view_group_nodes( + raw_view, + nodes_by_id, + containers_by_id, + node_parent, + layer_parent, + ) + requested_ids = _semantic_view_requested_ids(raw_view) + requested_ids.update(group_nodes) + explicitly_requested_container_ids = { + container_id for container_id in requested_ids if container_id in containers_by_id + } + flat_container_nodes: dict[str, dict[str, Any]] = {} + selection_requested_ids = set(requested_ids) + if layout == "flat": + flat_container_ids = {container_id for container_id in requested_ids if container_id in containers_by_id} + selection_requested_ids.difference_update(flat_container_ids) + flat_container_nodes = _semantic_view_flat_container_nodes(flat_container_ids, containers_by_id) + selected_nodes, selected_containers = _select_view_elements( + selection_requested_ids, + nodes_by_id, + containers_by_id, + node_parent, + layer_parent, + include_container_ancestors=layout == "contained", + ) + selected_group_ids = set(group_nodes) + if selected_group_ids: + summarized_member_ids = { + member_id + for group_id in selected_group_ids + for member_id in group_nodes.get(group_id, {}).get("members", []) + if isinstance(member_id, str) + } + selected_nodes.difference_update(summarized_member_ids) + if layout == "contained": + for group_id in selected_group_ids: + selected_containers.update(_container_ancestor_chain(group_node_parent.get(group_id), layer_parent)) + selected_flat_container_ids = set(flat_container_nodes) + selected_ids = selected_nodes | selected_containers | selected_group_ids | selected_flat_container_ids + semantic_view_edges = _semantic_view_edges(raw_view, selected_ids) + context_view_edges = _context_view_edges(architecture_context, selected_ids) + if semantic_view_edges: + labeled_context_edges = _deterministic_labeled_context_edges(architecture_context, context_view_edges) + view_edges = _dedupe_edges( + [ + *labeled_context_edges, + *( + edge + for edge in semantic_view_edges + if not _is_covered_by_deterministic_edge(edge.from_id, edge.to_id, labeled_context_edges) + ), + ] + ) + else: + view_edges = context_view_edges + edge_container_ids = { + endpoint_id + for edge in view_edges + for endpoint_id in (edge.from_id, edge.to_id) + if endpoint_id in containers_by_id + } + selected_containers = _prune_empty_view_containers( + selected_containers, + selected_nodes | selected_group_ids, + {**node_parent, **group_node_parent}, + layer_parent, + keep_container_ids=explicitly_requested_container_ids | edge_container_ids, + ) + render_node_parent = {**node_parent, **group_node_parent} + if view_id == "overview" and layout == "contained": + selected_containers, render_node_parent = _collapse_noisy_overview_network_containers( + selected_containers, + selected_nodes | selected_group_ids, + containers_by_id, + render_node_parent, + layer_parent, + keep_container_ids=explicitly_requested_container_ids | edge_container_ids, + ) + selected_ids = selected_nodes | selected_containers | selected_group_ids | selected_flat_container_ids + if not selected_nodes and not selected_containers and not selected_group_ids and not selected_flat_container_ids: + return None + + view_containers = { + container_id: containers_by_id[container_id] + for container_id in containers_by_id + if container_id in selected_containers + } + view_nodes = {node_id: nodes_by_id[node_id] for node_id in nodes_by_id if node_id in selected_nodes} + view_nodes.update(group_nodes) + view_nodes.update(flat_container_nodes) + if view_id == "overview": + view_containers = _with_detail_anchor_labels(view_containers, detail_anchor_labels, multiline=False) + view_nodes = _with_detail_anchor_labels(view_nodes, detail_anchor_labels) + view_layer_parent = { + container_id: parent_id + for container_id, parent_id in layer_parent.items() + if container_id in view_containers and parent_id in view_containers + } + view_node_parent = { + node_id: parent_id + for node_id, parent_id in render_node_parent.items() + if node_id in view_nodes and parent_id in view_containers + } + mermaid_source = _render_context_mermaid( + view_containers, + view_nodes, + view_edges, + view_layer_parent, + view_node_parent, + rules, + ) + view_context = { + "id": view_id, + "title": title, + "purpose": purpose, + "anchors": anchors, + "nodes": sorted(view_nodes), + "containers": sorted(view_containers), + "edges": [ + {"from": edge.from_id, "to": edge.to_id, "style": edge.style, "label": edge.label} for edge in view_edges + ], + "layout": layout, + "rendered_as": "filtered_architecture_view", + } + return ArchitectureViewResult( + id=view_id, + title=title, + purpose=purpose, + mermaid_source=mermaid_source, + architecture_context=view_context, + ) + + +def _semantic_detail_anchor_labels(raw_views: list[Any]) -> dict[str, list[str]]: + labels_by_anchor: dict[str, list[str]] = {} + for index, raw_view_value in enumerate(raw_views, start=1): + if not isinstance(raw_view_value, dict): + continue + raw_view = cast("dict[str, Any]", raw_view_value) + view_id = _semantic_view_id(raw_view, index) + if view_id == "overview" or not view_id.startswith("detail_"): + continue + title = _semantic_view_text(raw_view.get("title"), default=view_id) + for anchor_id in sorted(_semantic_view_anchor_ids(raw_view)): + labels_by_anchor.setdefault(anchor_id, []).append(title) + return labels_by_anchor + + +def _semantic_view_anchor_ids(raw_view: dict[str, Any]) -> set[str]: + anchors: set[str] = set() + for key in ("anchors", "anchor_ids"): + value = raw_view.get(key) + if isinstance(value, list): + anchors.update(item.strip() for item in value if isinstance(item, str) and item.strip()) + return anchors + + +def _semantic_view_group_nodes( + raw_view: dict[str, Any], + nodes_by_id: dict[str, dict[str, Any]], + containers_by_id: dict[str, dict[str, Any]], + node_parent: dict[str, str], + layer_parent: dict[str, str], +) -> tuple[dict[str, dict[str, Any]], dict[str, str]]: + group_nodes: dict[str, dict[str, Any]] = {} + group_parent: dict[str, str] = {} + raw_groups = raw_view.get("groups") + if not isinstance(raw_groups, list): + return group_nodes, group_parent + for raw_group_value in raw_groups: + if not isinstance(raw_group_value, dict): + continue + raw_group = cast("dict[str, Any]", raw_group_value) + group_id = _semantic_view_group_id(raw_group) + if group_id is None or group_id in group_nodes or group_id in nodes_by_id or group_id in containers_by_id: + continue + member_ids = [ + member_id + for member_id in _semantic_view_group_member_ids(raw_group) + if member_id in nodes_by_id and member_id not in group_nodes + ] + if not member_ids: + continue + common_parent = _nearest_common_member_container(member_ids, node_parent, layer_parent) + label = _semantic_view_group_label( + raw_group, + group_id, + member_ids, + nodes_by_id, + containers_by_id, + node_parent, + layer_parent, + common_parent, + ) + group_nodes[group_id] = { + "id": group_id, + "label": label, + "type": VIEW_SUMMARY_GROUP_TYPE, + "members": member_ids, + } + explicit_parent = raw_group.get("parent") or raw_group.get("container") + if isinstance(explicit_parent, str) and explicit_parent.strip() in containers_by_id: + group_parent[group_id] = explicit_parent.strip() + continue + if common_parent is not None: + group_parent[group_id] = common_parent + return group_nodes, group_parent + + +def _semantic_view_flat_container_nodes( + container_ids: set[str], + containers_by_id: dict[str, dict[str, Any]], +) -> dict[str, dict[str, Any]]: + return { + container_id: { + "id": container_id, + "label": str(containers_by_id[container_id].get("label") or container_id), + "type": str(containers_by_id[container_id].get("type") or ""), + } + for container_id in sorted(container_ids) + if container_id in containers_by_id + } + + +def _semantic_view_group_id(raw_group: dict[str, Any]) -> str | None: + value = raw_group.get("id") + if not isinstance(value, str) or not value.strip(): + value = raw_group.get("group_id") + if not isinstance(value, str) or not value.strip(): + return None + group_id = value.strip() + if not re.match(r"^[A-Za-z][A-Za-z0-9_]*$", group_id): + return None + return group_id + + +def _semantic_view_group_member_ids(raw_group: dict[str, Any]) -> list[str]: + value = raw_group.get("members") + if not isinstance(value, list): + value = raw_group.get("member_ids") + if not isinstance(value, list): + return [] + return list(dict.fromkeys(item.strip() for item in value if isinstance(item, str) and item.strip())) + + +def _semantic_view_group_label( + raw_group: dict[str, Any], + group_id: str, + member_ids: list[str], + nodes_by_id: dict[str, dict[str, Any]], + containers_by_id: dict[str, dict[str, Any]], + node_parent: dict[str, str], + layer_parent: dict[str, str], + common_parent: str | None, +) -> str: + base_label = _semantic_view_text(raw_group.get("label"), default=group_id) + member_labels = [ + _semantic_base_label(str(nodes_by_id[member_id].get("label") or member_id)) for member_id in member_ids[:4] + ] + lines = [base_label, *(f"+ {label}" for label in member_labels if label)] + placement_summary = _semantic_view_group_placement_summary( + member_ids, + containers_by_id, + node_parent, + layer_parent, + common_parent, + ) + if placement_summary: + lines.append(f"+ {placement_summary}") + remaining_count = len(member_ids) - len(member_labels) + if remaining_count > 0: + remaining_label = "其他" if get_current_language() == "zh" else "more" + lines.append(f"+ {remaining_label} x{remaining_count}") + return "\\n".join(lines) + + +def _nearest_common_member_container( + member_ids: list[str], + node_parent: dict[str, str], + layer_parent: dict[str, str], +) -> str | None: + chains = [ + _container_ancestor_list(node_parent.get(member_id), layer_parent) + for member_id in member_ids + if node_parent.get(member_id) is not None + ] + if not chains: + return None + common = set(chains[0]) + for chain in chains[1:]: + common.intersection_update(chain) + for container_id in chains[0]: + if container_id in common: + return container_id + return None + + +def _semantic_view_group_placement_summary( + member_ids: list[str], + containers_by_id: dict[str, dict[str, Any]], + node_parent: dict[str, str], + layer_parent: dict[str, str], + common_parent: str | None, +) -> str | None: + if common_parent is not None: + return None + root_container_ids = [ + _root_container_id(node_parent.get(member_id), layer_parent) + for member_id in member_ids + if node_parent.get(member_id) is not None + ] + unique_root_ids = list(dict.fromkeys(container_id for container_id in root_container_ids if container_id)) + if len(unique_root_ids) < 2: + return None + root_labels = [str(containers_by_id[container_id].get("label") or container_id) for container_id in unique_root_ids] + kind = _semantic_group_container_kind(root_labels) + if get_current_language() == "zh": + return f"跨 {kind} x{len(unique_root_ids)}" + return f"across {kind} x{len(unique_root_ids)}" + + +def _root_container_id(container_id: str | None, layer_parent: dict[str, str]) -> str | None: + chain = _container_ancestor_list(container_id, layer_parent) + return chain[-1] if chain else None + + +def _semantic_group_container_kind(labels: list[str]) -> str: + if labels and all("VPC" in label for label in labels): + return "VPC" + if labels and all("VSwitch" in label or "交换机" in label for label in labels): + return "VSwitch" + kinds = {re.split(r"\s|\(", label.strip(), maxsplit=1)[0] for label in labels if label.strip()} + if len(kinds) == 1: + return next(iter(kinds)) + return "边界" if get_current_language() == "zh" else "boundaries" + + +def _with_detail_anchor_labels( + items: dict[str, dict[str, Any]], + detail_anchor_labels: dict[str, list[str]], + *, + multiline: bool = True, +) -> dict[str, dict[str, Any]]: + annotated: dict[str, dict[str, Any]] = {} + for item_id, item in items.items(): + labels = detail_anchor_labels.get(item_id) + if not labels: + annotated[item_id] = item + continue + annotated[item_id] = { + **item, + "label": _append_detail_anchor_label(str(item.get("label") or item_id), labels, multiline=multiline), + } + return annotated + + +def _append_detail_anchor_label(label: str, detail_titles: list[str], *, multiline: bool = True) -> str: + unique_titles = list(dict.fromkeys(title for title in detail_titles if title)) + if not unique_titles: + return label + detail_label = " / ".join(unique_titles) + if not multiline: + return f"{label}（展开: {detail_label}）" + return f"{label}\\n展开: {detail_label}" + + +def _semantic_view_id(raw_view: dict[str, Any], index: int) -> str: + value = raw_view.get("id") + if not isinstance(value, str) or not value.strip(): + value = raw_view.get("view_id") + if not isinstance(value, str) or not value.strip(): + return f"view_{index}" + normalized = re.sub(r"[^A-Za-z0-9_]+", "_", value.strip()) + return normalized.strip("_") or f"view_{index}" + + +def _semantic_view_text(value: Any, *, default: str) -> str: + if not isinstance(value, str): + return default + text = " ".join(value.strip().split()) + return text[:48] if text else default + + +def _semantic_view_layout(raw_view: dict[str, Any], view_id: str) -> str: + value = raw_view.get("layout") + if not isinstance(value, str) or not value.strip(): + value = raw_view.get("render_mode") + if isinstance(value, str): + normalized = value.strip().lower().replace("-", "_") + if normalized in {"contained", "flat"}: + return normalized + if normalized in {"with_containment", "placement", "network"}: + return "contained" + if normalized in {"relationship", "relationships", "logical"}: + return "flat" + return "flat" + + +def _semantic_view_requested_ids(raw_view: dict[str, Any]) -> set[str]: + requested: set[str] = set() + for key in ("nodes", "node_ids", "containers", "container_ids"): + value = raw_view.get(key) + if isinstance(value, list): + requested.update(item.strip() for item in value if isinstance(item, str) and item.strip()) + for raw_edge in raw_view.get("edges", []) if isinstance(raw_view.get("edges"), list) else []: + if not isinstance(raw_edge, dict): + continue + from_id = _semantic_edge_endpoint(raw_edge, "from") + to_id = _semantic_edge_endpoint(raw_edge, "to") + if from_id is not None: + requested.add(from_id) + if to_id is not None: + requested.add(to_id) + return requested + + +def _context_nodes_by_id(architecture_context: dict[str, Any]) -> dict[str, dict[str, Any]]: + nodes: dict[str, dict[str, Any]] = {} + for item in architecture_context.get("visible_nodes", []): + if isinstance(item, dict) and isinstance(item.get("id"), str): + nodes[item["id"]] = item + return nodes + + +def _context_containers_by_id(architecture_context: dict[str, Any]) -> dict[str, dict[str, Any]]: + containers: dict[str, dict[str, Any]] = {} + for item in architecture_context.get("containers", []): + if isinstance(item, dict) and isinstance(item.get("id"), str): + containers[item["id"]] = item + return containers + + +def _context_node_parent(architecture_context: dict[str, Any]) -> dict[str, str]: + parents: dict[str, str] = {} + for item in architecture_context.get("containment", []): + if isinstance(item, dict) and isinstance(item.get("resource"), str) and isinstance(item.get("container"), str): + parents[item["resource"]] = item["container"] + return parents + + +def _context_layer_parent(containers_by_id: dict[str, dict[str, Any]]) -> dict[str, str]: + parents: dict[str, str] = {} + for container_id, container in containers_by_id.items(): + parent = container.get("parent") + if isinstance(parent, str) and parent in containers_by_id: + parents[container_id] = parent + return parents + + +def _select_view_elements( + requested_ids: set[str], + nodes_by_id: dict[str, dict[str, Any]], + containers_by_id: dict[str, dict[str, Any]], + node_parent: dict[str, str], + layer_parent: dict[str, str], + *, + include_container_ancestors: bool, +) -> tuple[set[str], set[str]]: + selected_nodes = {node_id for node_id in requested_ids if node_id in nodes_by_id} + selected_containers = {container_id for container_id in requested_ids if container_id in containers_by_id} + + for container_id in tuple(selected_containers): + selected_nodes.update( + node_id + for node_id in nodes_by_id + if container_id in _container_ancestor_chain(node_parent.get(node_id), layer_parent) + ) + + if include_container_ancestors: + for node_id in selected_nodes: + selected_containers.update(_container_ancestor_chain(node_parent.get(node_id), layer_parent)) + for container_id in tuple(selected_containers): + selected_containers.update(_container_ancestor_chain(layer_parent.get(container_id), layer_parent)) + + return selected_nodes, selected_containers + + +def _prune_empty_view_containers( + selected_containers: set[str], + selected_node_ids: set[str], + node_parent: dict[str, str], + layer_parent: dict[str, str], + *, + keep_container_ids: set[str], +) -> set[str]: + kept = set(selected_containers) + changed = True + while changed: + changed = False + for container_id in sorted(kept): + if container_id in keep_container_ids: + continue + has_selected_node = any( + node_id in selected_node_ids and parent_id == container_id for node_id, parent_id in node_parent.items() + ) + has_selected_child_container = any( + child_id in kept and parent_id == container_id for child_id, parent_id in layer_parent.items() + ) + if has_selected_node or has_selected_child_container: + continue + kept.remove(container_id) + changed = True + return kept + + +def _collapse_noisy_overview_network_containers( + selected_containers: set[str], + selected_node_ids: set[str], + containers_by_id: dict[str, dict[str, Any]], + node_parent: dict[str, str], + layer_parent: dict[str, str], + *, + keep_container_ids: set[str], +) -> tuple[set[str], dict[str, str]]: + noisy_children_by_parent: dict[str, list[str]] = {} + for container_id in selected_containers: + if container_id in keep_container_ids: + continue + container = containers_by_id.get(container_id) + if not container or container.get("type") != "ALIYUN::ECS::VSwitch": + continue + parent_id = layer_parent.get(container_id) + if parent_id in selected_containers: + noisy_children_by_parent.setdefault(parent_id, []).append(container_id) + + collapsed_container_ids = { + container_id + for child_ids in noisy_children_by_parent.values() + if len(child_ids) >= 3 + for container_id in child_ids + } + if not collapsed_container_ids: + return selected_containers, node_parent + + collapsed_selected_containers = selected_containers - collapsed_container_ids + collapsed_node_parent = dict(node_parent) + for node_id in selected_node_ids: + parent_id = collapsed_node_parent.get(node_id) + if parent_id not in collapsed_container_ids: + continue + replacement_parent_id = _nearest_selected_container_ancestor( + parent_id, + collapsed_selected_containers, + layer_parent, + ) + if replacement_parent_id is None: + collapsed_node_parent.pop(node_id, None) + else: + collapsed_node_parent[node_id] = replacement_parent_id + + return collapsed_selected_containers, collapsed_node_parent + + +def _nearest_selected_container_ancestor( + container_id: str, + selected_containers: set[str], + layer_parent: dict[str, str], +) -> str | None: + current = layer_parent.get(container_id) + while current is not None: + if current in selected_containers: + return current + current = layer_parent.get(current) + return None + + +def _container_ancestor_chain(container_id: str | None, layer_parent: dict[str, str]) -> set[str]: + return set(_container_ancestor_list(container_id, layer_parent)) + + +def _container_ancestor_list(container_id: str | None, layer_parent: dict[str, str]) -> list[str]: + ancestors: set[str] = set() + ordered: list[str] = [] + current = container_id + while current is not None and current not in ancestors: + ancestors.add(current) + ordered.append(current) + current = layer_parent.get(current) + return ordered + + +def _semantic_view_edges(raw_view: dict[str, Any], selected_ids: set[str]) -> list[GraphEdge]: + raw_edges = raw_view.get("edges") + if not isinstance(raw_edges, list): + return [] + edges: list[GraphEdge] = [] + for raw_edge in raw_edges: + if not isinstance(raw_edge, dict): + continue + from_id = _semantic_edge_endpoint(raw_edge, "from") + to_id = _semantic_edge_endpoint(raw_edge, "to") + label = _semantic_edge_label(raw_edge) + kind = raw_edge.get("kind") + if not isinstance(kind, str) or kind not in SEMANTIC_EDGE_STYLES: + kind = "inferred" + if from_id is None or to_id is None or label is None: + continue + if from_id not in selected_ids or to_id not in selected_ids: + continue + edges.append(GraphEdge(from_id, to_id, SEMANTIC_EDGE_STYLES[kind], label)) + return _dedupe_edges(edges) + + +def _context_view_edges(architecture_context: dict[str, Any], selected_ids: set[str]) -> list[GraphEdge]: + edges: list[GraphEdge] = [] + for raw_edge in architecture_context.get("visible_edges", []): + if not isinstance(raw_edge, dict): + continue + from_id = raw_edge.get("from") + to_id = raw_edge.get("to") + style = raw_edge.get("style") + label = raw_edge.get("label") + if not isinstance(from_id, str) or not isinstance(to_id, str) or not isinstance(style, str): + continue + if from_id not in selected_ids or to_id not in selected_ids: + continue + edges.append(GraphEdge(from_id, to_id, style, label if isinstance(label, str) else None)) + return _dedupe_edges(edges) + + +def _deterministic_labeled_context_edges( + architecture_context: dict[str, Any], + context_edges: list[GraphEdge], +) -> list[GraphEdge]: + accepted_edges = architecture_context.get("semantic_plan", {}).get("accepted_edges") + if not isinstance(accepted_edges, list): + accepted_edges = [] + semantic_pairs = set() + for edge in accepted_edges: + if not isinstance(edge, dict): + continue + semantic_pairs.add((str(edge.get("from") or ""), str(edge.get("to") or ""))) + return [ + edge for edge in context_edges if edge.label is not None and (edge.from_id, edge.to_id) not in semantic_pairs + ] + + +def _render_context_mermaid( + containers: dict[str, dict[str, Any]], + nodes: dict[str, dict[str, Any]], + edges: list[GraphEdge], + layer_parent: dict[str, str], + node_parent: dict[str, str], + rules: ArchitectureRules, +) -> str: + lines: list[str] = ["graph TD"] + sg_style_ids: list[str] = [] + security_group_layer_types = set(rules.containment_types("security_group")) + + def render_layer(layer_id: str, indent: str) -> None: + layer = containers[layer_id] + sub_id = f"layer_{layer_id}" + label = str(layer.get("label") or layer_id) + lines.append(f"{indent}subgraph {sub_id} [{_subgraph_label(label)}]") + if layer.get("type") in security_group_layer_types: + sg_style_ids.append(sub_id) + for child_layer_id in containers: + if layer_parent.get(child_layer_id) == layer_id: + render_layer(child_layer_id, indent + " ") + for child_node_id in nodes: + if node_parent.get(child_node_id) == layer_id: + lines.append(f'{indent} {child_node_id}["{nodes[child_node_id].get("label") or child_node_id}"]') + lines.append(f"{indent}end") + + for layer_id in containers: + if layer_id not in layer_parent: + render_layer(layer_id, " ") + + for node_id, node in nodes.items(): + if node_id not in node_parent: + lines.append(f' {node_id}["{node.get("label") or node_id}"]') + + for edge in _dedupe_edges(edges): + from_endpoint = _context_mermaid_endpoint(edge.from_id, nodes, containers) + to_endpoint = _context_mermaid_endpoint(edge.to_id, nodes, containers) + if from_endpoint is None or to_endpoint is None: + continue + operator = rules.edge_operator(edge.style) + if edge.label: + lines.append(f" {from_endpoint} {operator}|{_edge_label(edge.label)}| {to_endpoint}") + else: + lines.append(f" {from_endpoint} {operator} {to_endpoint}") + + for style_id in sg_style_ids: + lines.append(f" style {style_id} stroke-dasharray: 5 5") + + return "\n".join(lines) + + +def _context_mermaid_endpoint( + endpoint_id: str, + nodes: dict[str, dict[str, Any]], + containers: dict[str, dict[str, Any]], +) -> str | None: + if endpoint_id in nodes: + return endpoint_id + if endpoint_id in containers: + return f"layer_{endpoint_id}" + return None + + +def _error_architecture_context(reason: str) -> dict[str, Any]: + return { + "version": "1.0", + "error": reason, + "resources": [], + "containers": [], + "visible_nodes": [], + "containment": [], + "explicit_relations": [], + "property_references": [], + "all_property_references": [], + "route_intents": [], + "orchestration_actions": [], + "node_label_hints": [], + "attachments": [], + "concept_nodes": [], + "concept_groups": [], + "kubernetes_applications": [], + "visible_edges": [], + "semantic_plan": {"accepted_edges": [], "rejected_edges": []}, + "llm_semantic_plan_schema": _llm_semantic_plan_schema(), + "target_language": _target_language_context(), + } + + +def _target_language_context() -> dict[str, str]: + language = get_current_language() + names = { + "zh": "Chinese", + "en": "English", + "es": "Spanish", + "fr": "French", + "de": "German", + "ja": "Japanese", + "pt": "Portuguese", + } + return {"code": language, "name": names.get(language, language)} + + +def _resource_roles( + layers: dict[str, TemplateResource], + nodes: dict[str, TemplateResource], + auxiliary: dict[str, TemplateResource], +) -> dict[str, str]: + roles: dict[str, str] = {resource_id: "container" for resource_id in layers} + roles.update({resource_id: "node" for resource_id in nodes}) + roles.update({resource_id: "auxiliary" for resource_id in auxiliary}) + return roles + + +def _context_layer_label(layer: TemplateResource, params: dict[str, Any], rules: ArchitectureRules) -> str: + label = _localized_layer_label(layer, params, rules) + return label + + +def _localized_layer_label(layer: TemplateResource, params: dict[str, Any], rules: ArchitectureRules) -> str: + base_label = layer.label.split("\\n", 1)[0] + label = _(rules.legacy_layer_labels.get(layer.resource_type, base_label)) + cidr_layer_types = set(rules.containment_types("vpc")) | set(rules.containment_types("vswitch")) + if layer.resource_type in cidr_layer_types: + cidr = _resolve_cidr(layer.properties.get("CidrBlock"), params) + if cidr: + label = f"{label} ({cidr})" + return label + + +def _attachment_context( + auxiliary: dict[str, TemplateResource], + relations: list[ResourceRelation], + resources: dict[str, TemplateResource], +) -> list[dict[str, str]]: + attachments: list[dict[str, str]] = [] + by_source = _relations_by_source(relations) + for resource in auxiliary.values(): + source_relations = by_source.get(resource.logical_id, []) + main_ref = _main_resource_ref(resource, source_relations) + if main_ref is None or main_ref not in resources: + continue + for relation in source_relations: + if relation.target_id == main_ref or relation.target_id not in resources: + continue + attachments.append( + { + "via": resource.logical_id, + "marker": main_ref, + "target": relation.target_id, + "property": relation.property_name, + "marker_type": resources[main_ref].resource_type, + "target_type": resources[relation.target_id].resource_type, + } + ) + return attachments + + +def _network_attachment_context(resources: dict[str, TemplateResource]) -> list[dict[str, str]]: + attachments: list[dict[str, str]] = [] + for resource in resources.values(): + if resource.resource_type == "ALIYUN::CEN::CenInstanceAttachment": + item = _cen_child_instance_attachment_context(resource, resources) + elif resource.resource_type == "ALIYUN::CEN::TransitRouterVpcAttachment": + item = _transit_router_child_attachment_context( + resource, + resources, + hub_property="TransitRouterId", + child_type="VPC", + child_property="VpcId", + ) + elif resource.resource_type == "ALIYUN::CEN::TransitRouterVbrAttachment": + item = _transit_router_child_attachment_context( + resource, + resources, + hub_property="TransitRouterId", + child_type="VBR", + child_property="VbrId", + ) + elif resource.resource_type == "ALIYUN::CEN::TransitRouterPeerAttachment": + item = _transit_router_child_attachment_context( + resource, + resources, + hub_property="TransitRouterId", + child_type="TransitRouter", + child_property="PeerTransitRouterId", + child_region_property="PeerTransitRouterRegionId", + ) + else: + item = None + if item is not None: + attachments.append(item) + return attachments + + +def _cen_child_instance_attachment_context( + resource: TemplateResource, + resources: dict[str, TemplateResource], +) -> dict[str, str]: + properties = resource.properties + item = { + "id": resource.logical_id, + "type": resource.resource_type, + "network": "CEN", + "cen": _resource_ref_or_value_summary(properties.get("CenId"), resources), + "child_instance_type": _resource_ref_or_value_summary(properties.get("ChildInstanceType"), resources), + "child_instance_id": _resource_ref_or_value_summary(properties.get("ChildInstanceId"), resources), + "child_instance_region": _resource_ref_or_value_summary(properties.get("ChildInstanceRegionId"), resources), + } + _add_child_resource_context(item, properties.get("ChildInstanceId"), resources) + return {key: value for key, value in item.items() if value} + + +def _transit_router_child_attachment_context( + resource: TemplateResource, + resources: dict[str, TemplateResource], + *, + hub_property: str, + child_type: str, + child_property: str, + child_region_property: str | None = None, +) -> dict[str, str]: + properties = resource.properties + item = { + "id": resource.logical_id, + "type": resource.resource_type, + "network": "CEN", + "transit_router": _resource_ref_or_value_summary(properties.get(hub_property), resources), + "child_instance_type": child_type, + "child_instance_id": _resource_ref_or_value_summary(properties.get(child_property), resources), + } + if child_region_property is not None: + item["child_instance_region"] = _resource_ref_or_value_summary(properties.get(child_region_property), resources) + _add_child_resource_context(item, properties.get(child_property), resources) + return {key: value for key, value in item.items() if value} + + +def _add_child_resource_context( + item: dict[str, str], + value: Any, + resources: dict[str, TemplateResource], +) -> None: + child_refs = _extract_resource_refs(value, resources) + if not child_refs: + return + child_id = child_refs[0] + child_resource = resources.get(child_id) + if child_resource is None: + return + item["child_resource"] = child_id + item["child_resource_type"] = child_resource.resource_type + + +def _resource_ref_or_value_summary(value: Any, resources: dict[str, TemplateResource]) -> str: + refs = _extract_resource_refs(value, resources) + if refs: + return refs[0] if len(refs) == 1 else ", ".join(refs) + if isinstance(value, str): + return value + if isinstance(value, dict): + ref = value.get("Ref") + if isinstance(ref, str) and ref: + return f"Ref:{ref}" + get_att = value.get("Fn::GetAtt") + if isinstance(get_att, list) and get_att and isinstance(get_att[0], str): + return f"GetAtt:{'.'.join(str(part) for part in get_att)}" + if isinstance(get_att, str) and get_att: + return f"GetAtt:{get_att}" + return "" + + +def _property_reference_context( + resources: dict[str, TemplateResource], + visible_nodes: dict[str, TemplateResource], +) -> list[dict[str, str]]: + visible_node_ids = set(visible_nodes) + references: list[dict[str, str]] = [] + seen: set[tuple[str, str, str]] = set() + for source in resources.values(): + if source.logical_id not in visible_node_ids: + continue + for property_name, property_value in source.properties.items(): + for target_id in _extract_resource_refs(property_value, resources): + if target_id not in visible_node_ids: + continue + key = (source.logical_id, target_id, property_name) + if source.logical_id == target_id or key in seen: + continue + target = resources[target_id] + seen.add(key) + references.append( + { + "source": source.logical_id, + "target": target_id, + "property": property_name, + "source_type": source.resource_type, + "target_type": target.resource_type, + } + ) + return references + + +def _all_property_reference_context( + resources: dict[str, TemplateResource], + visible_nodes: dict[str, TemplateResource], +) -> list[dict[str, str | bool]]: + visible_node_ids = set(visible_nodes) + references: list[dict[str, str | bool]] = [] + seen: set[tuple[str, str, str]] = set() + for source in resources.values(): + if source.logical_id not in visible_node_ids: + continue + for property_name, property_value in source.properties.items(): + for target_id in _extract_resource_refs(property_value, resources): + if target_id not in resources: + continue + key = (source.logical_id, target_id, property_name) + if source.logical_id == target_id or key in seen: + continue + target = resources[target_id] + seen.add(key) + references.append( + { + "source": source.logical_id, + "target": target_id, + "property": property_name, + "source_type": source.resource_type, + "target_type": target.resource_type, + "target_visible": target_id in visible_node_ids, + } + ) + return references + + +def _route_intent_context(resources: dict[str, TemplateResource]) -> list[dict[str, str]]: + intents: list[dict[str, str]] = [] + for resource in resources.values(): + if resource.resource_type == "ALIYUN::ECS::Route": + item = _ecs_route_intent_context(resource, resources) + elif resource.resource_type == "ALIYUN::CEN::TransitRouterRouteEntry": + item = _cen_route_intent_context(resource, resources) + else: + item = {} + if item: + intents.append(item) + return intents + + +def _ecs_route_intent_context( + resource: TemplateResource, + resources: dict[str, TemplateResource], +) -> dict[str, str]: + properties = resource.properties + item = { + "id": resource.logical_id, + "type": resource.resource_type, + "destination": _route_destination_summary(properties), + "route_table": _resource_ref_or_value_summary(properties.get("RouteTableId"), resources), + "next_hop_type": _scalar_property_summary(properties.get("NextHopType")), + "next_hop": _resource_ref_or_value_summary(properties.get("NextHopId"), resources), + } + _add_route_resource_context(item, properties.get("RouteTableId"), resources, prefix="route_table") + _add_route_resource_context(item, properties.get("NextHopId"), resources, prefix="next_hop") + return {key: value for key, value in item.items() if value} + + +def _cen_route_intent_context( + resource: TemplateResource, + resources: dict[str, TemplateResource], +) -> dict[str, str]: + properties = resource.properties + item = { + "id": resource.logical_id, + "type": resource.resource_type, + "destination": _route_destination_summary(properties), + "route_table": _resource_ref_or_value_summary(properties.get("TransitRouterRouteTableId"), resources), + "next_hop_type": _scalar_property_summary(properties.get("TransitRouterRouteEntryNextHopType")), + "next_hop": _resource_ref_or_value_summary(properties.get("TransitRouterRouteEntryNextHopId"), resources), + } + _add_route_resource_context(item, properties.get("TransitRouterRouteTableId"), resources, prefix="route_table") + _add_route_resource_context(item, properties.get("TransitRouterRouteEntryNextHopId"), resources, prefix="next_hop") + return {key: value for key, value in item.items() if value} + + +def _route_destination_summary(properties: dict[str, Any]) -> str: + for property_name in ( + "DestinationCidrBlock", + "DestinationIpv6CidrBlock", + "DestinationChildInstanceCidrBlock", + "TransitRouterRouteEntryDestinationCidrBlock", + ): + summary = _scalar_property_summary(properties.get(property_name)) + if summary: + return summary + return "" + + +def _scalar_property_summary(value: Any) -> str: + if isinstance(value, str): + return value + if isinstance(value, (int, float, bool)): + return str(value) + return "" + + +def _add_route_resource_context( + item: dict[str, str], + value: Any, + resources: dict[str, TemplateResource], + *, + prefix: str, +) -> None: + refs = _extract_resource_refs(value, resources) + if not refs: + return + resource_id = refs[0] + resource = resources.get(resource_id) + if resource is None: + return + item[f"{prefix}_resource"] = resource_id + item[f"{prefix}_resource_type"] = resource.resource_type + + +def _orchestration_action_context( + resources: dict[str, TemplateResource], + visible_nodes: dict[str, TemplateResource], + rules: ArchitectureRules, +) -> list[dict[str, Any]]: + actions: list[dict[str, Any]] = [] + visible_node_ids = set(visible_nodes) + for resource in resources.values(): + action_rule = _orchestration_action_rule(resource, rules) + if action_rule is None or not action_rule.target_properties: + continue + command_id = _first_property_ref(resource, resources, action_rule.command_properties) + evidence_resource = resources.get(command_id) if command_id is not None else resource + evidence_rule = _orchestration_action_rule(evidence_resource, rules) if evidence_resource is not None else None + evidence_properties = evidence_rule.evidence_properties if evidence_rule is not None else () + targets = _property_ref_context_items( + resource, + resources, + visible_node_ids, + action_rule.target_properties, + ) + referenced_resources = ( + _property_ref_context_items(evidence_resource, resources, visible_node_ids, evidence_properties) + if evidence_resource is not None + else [] + ) + if not targets and not referenced_resources: + continue + actions.append( + { + "id": resource.logical_id, + "type": resource.resource_type, + "command": command_id, + "targets": targets, + "referenced_resources": referenced_resources, + } + ) + return actions + + +def _orchestration_action_rule( + resource: TemplateResource | None, + rules: ArchitectureRules, +) -> CompactOrchestrationAction | None: + if resource is None: + return None + for action_rule in rules.compact_orchestration_actions: + if resource.resource_type in action_rule.resource_types: + return action_rule + return None + + +def _first_property_ref( + resource: TemplateResource, + resources: dict[str, TemplateResource], + property_names: tuple[str, ...], +) -> str | None: + for item in _property_ref_context_items(resource, resources, set(), property_names): + resource_id = item.get("id") + if isinstance(resource_id, str): + return resource_id + return None + + +def _property_ref_context_items( + resource: TemplateResource, + resources: dict[str, TemplateResource], + visible_node_ids: set[str], + property_names: tuple[str, ...], +) -> list[dict[str, str | bool]]: + if not property_names: + return [] + property_name_set = set(property_names) + items: list[dict[str, str | bool]] = [] + seen: set[tuple[str, str]] = set() + for property_name, property_value in resource.properties.items(): + if property_name not in property_name_set: + continue + for target_id in _extract_resource_refs(property_value, resources): + target = resources.get(target_id) + if target is None: + continue + key = (target_id, property_name) + if key in seen: + continue + seen.add(key) + items.append( + { + "id": target_id, + "type": target.resource_type, + "property": property_name, + "visible": target_id in visible_node_ids, + } + ) + return items + + +def _node_label_hint_context(visible_nodes: dict[str, TemplateResource]) -> list[dict[str, Any]]: + hints: list[dict[str, Any]] = [] + for node in visible_nodes.values(): + node_hints = _node_label_hints(node.properties) + if not node_hints: + continue + hints.append( + { + "id": node.logical_id, + "label": node.label, + "type": node.resource_type, + "hints": node_hints, + } + ) + return hints + + +def _node_label_hints(properties: dict[str, Any]) -> dict[str, str]: + hint_keys = ( + "InstanceName", + "Name", + "LoadBalancerName", + "DBClusterDescription", + "DBInstanceDescription", + "NatGatewayName", + "VSwitchName", + ) + hints: dict[str, str] = {} + for key in hint_keys: + value = properties.get(key) + if isinstance(value, str) and value.strip(): + hints[key] = value.strip() + return hints + + +def _llm_semantic_plan_schema() -> dict[str, Any]: + return { + "node_labels": { + "required_fields": ["id", "label", "confidence"], + "confidence_values": ["high", "medium", "low"], + "max_label_chars": 32, + }, + "edges": { + "allowed_kinds": list(SEMANTIC_EDGE_KINDS), + "required_fields": ["from", "to", "kind", "label", "confidence"], + "confidence_values": ["high", "medium", "low"], + "max_label_chars": 18, + }, + "views": { + "required_fields": ["id", "title", "purpose", "layout", "nodes", "edges"], + "detail_required_fields": ["anchors"], + "optional_fields": { + "groups": { + "item_fields": ["id", "label", "members", "parent"], + "description": ( + "View-only summary nodes. members must be ids from visible_nodes; parent may be a container id." + ), + } + }, + "recommended_ids": [ + "overview", + "detail_app", + "detail_data", + "detail_network", + "detail_operations", + "detail_permissions", + ], + "allowed_layouts": ["flat", "contained"], + "layout_guidance": { + "flat": "logical drill-down view; use when placement boundaries are not important", + "contained": ( + "overview or detail placement view; use when VPC/VSwitch/region/security boundaries matter" + ), + }, + "max_overview_nodes": 8, + "max_detail_nodes": 12, + "max_edges_per_view": 8, + "anchor_guidance": "Every detail_ view must anchor to one or more ids present in the overview view.", + }, + } + + +def _compact_graph_if_needed( + layers: dict[str, TemplateResource], + nodes: dict[str, TemplateResource], + edges: list[GraphEdge], + node_parent: dict[str, str], + auxiliary: dict[str, TemplateResource], + relations: list[ResourceRelation], + rules: ArchitectureRules, +) -> tuple[ + dict[str, TemplateResource], + dict[str, TemplateResource], + list[GraphEdge], + dict[str, str], + bool, + dict[str, str], +]: + compactable_ids = {node_id for node_id, node in nodes.items() if _is_compact_supported(node)} + compactable_edges = [edge for edge in edges if edge.from_id in compactable_ids and edge.to_id in compactable_ids] + root_compactable_ids = {node_id for node_id in compactable_ids if node_id not in node_parent} + visible_element_count = len(layers) + len(nodes) + should_compact_by_size = ( + len(compactable_ids) > COMPACT_MIN_VISIBLE_NODES + or visible_element_count > COMPACT_MIN_VISIBLE_ELEMENTS + or len(compactable_edges) > COMPACT_MIN_EDGES + or len(root_compactable_ids) > COMPACT_MIN_ROOT_NODES + ) + foldable_overview_node_count = _foldable_overview_node_count(nodes, compactable_ids, rules) + should_compact_by_foldables = foldable_overview_node_count >= COMPACT_MIN_FOLDABLE_NODES or ( + foldable_overview_node_count >= 1 and visible_element_count >= COMPACT_MIN_VISIBLE_ELEMENTS_FOR_SINGLE_FOLDABLE + ) + if not should_compact_by_size and not should_compact_by_foldables: + return layers, nodes, edges, node_parent, False, {} + + target_resources = {**layers, **nodes} + folded_edges, folded_node_ids, folded_source_attachment_labels = _compact_relation_fold_edges( + {**auxiliary, **nodes}, + target_resources, + relations, + rules, + ) + attachment_labels, attached_marker_ids, attachment_targets = _compact_attachment_labels( + nodes, auxiliary, relations, rules + ) + attachment_edges = _compact_attachment_edges(nodes, relations, attachment_targets, rules) + attachment_labels = _propagate_attachment_labels(attachment_labels, attachment_targets) + bridge_via_resources = {**auxiliary, **layers, **nodes} + child_attachment_labels, child_attachment_ids, child_attachment_targets = _compact_child_attachment_labels( + {**auxiliary, **nodes}, {**target_resources, **auxiliary}, relations, rules + ) + child_attachment_labels, child_attachment_ids, child_attachment_targets = _filter_unresolved_child_attachments( + child_attachment_labels, + child_attachment_ids, + child_attachment_targets, + set(target_resources), + ) + bridge_attachment_labels, bridge_attachment_ids, bridge_attachment_targets = _compact_bridge_attachment_labels( + nodes, target_resources, bridge_via_resources, relations, rules + ) + attachment_labels = _merge_attachment_labels( + attachment_labels, + child_attachment_labels, + bridge_attachment_labels, + folded_source_attachment_labels, + ) + hidden_target_aliases = {**child_attachment_targets, **bridge_attachment_targets} + attachment_labels = _propagate_hidden_attachment_labels(attachment_labels, hidden_target_aliases) + concept_via_ids = { + node_id + for node_id, node in nodes.items() + if any(node.resource_type in rule.via_resource_types for rule in rules.compact_concept_nodes) + } + hidden_ids = ( + attached_marker_ids + | child_attachment_ids + | bridge_attachment_ids + | folded_node_ids + | { + node_id + for node_id, node in nodes.items() + if node_id in compactable_ids and node.short_type in rules.compact_hidden_short_types + } + ) + hidden_ids |= { + node_id + for node_id, node in nodes.items() + if node_id in compactable_ids and node.resource_type in rules.compact_orchestration_action_types + } + hidden_ids |= { + node_id + for node_id, node in nodes.items() + if node_id in compactable_ids + and node.resource_type in rules.compact_attachment_marker_types + and node_id not in attached_marker_ids + } + hidden_ids |= concept_via_ids + compact_nodes = {node_id: node for node_id, node in nodes.items() if node_id not in hidden_ids} + compact_edges = [edge for edge in edges if edge.from_id not in hidden_ids and edge.to_id not in hidden_ids] + compact_parent = {node_id: parent for node_id, parent in node_parent.items() if node_id in compact_nodes} + compact_endpoint_ids = set(compact_nodes) | set(layers) + compact_edges.extend( + edge for edge in folded_edges if edge.from_id in compact_endpoint_ids and edge.to_id in compact_endpoint_ids + ) + compact_edges.extend( + edge for edge in attachment_edges if edge.from_id in compact_nodes and edge.to_id in compact_nodes + ) + compact_attachment_labels = { + node_id: labels for node_id, labels in attachment_labels.items() if node_id in compact_nodes + } + compact_layer_labels = {layer_id: labels for layer_id, labels in attachment_labels.items() if layer_id in layers} + compact_layers = layers + compact_nodes, compact_parent, layer_summary_ids = _add_layer_attachment_summary_nodes( + compact_nodes, + compact_parent, + compact_layer_labels, + compact_layers, + rules, + ) + if layer_summary_ids: + compact_edges = _retarget_layer_edge_endpoints(compact_edges, layer_summary_ids) + hidden_target_aliases = _retarget_endpoint_aliases(hidden_target_aliases, layer_summary_ids) + + aggregate_groups = _aggregate_groups(compact_nodes, compact_edges, compact_parent) + if not aggregate_groups: + return ( + compact_layers, + _with_compact_labels(compact_nodes, rules, compact_attachment_labels), + _dedupe_edges(compact_edges), + compact_parent, + True, + _visible_endpoint_aliases(hidden_target_aliases, compact_nodes, compact_layers), + ) + + remapped_ids: dict[str, str] = {} + aggregated_nodes: dict[str, TemplateResource] = {} + aggregated_parent: dict[str, str] = {} + + for members in aggregate_groups: + first_node = compact_nodes[members[0]] + aggregate_id = _aggregate_node_id( + first_node.resource_type, + compact_parent.get(first_node.logical_id), + _semantic_compute_aggregate_role_key(first_node), + ) + for member_id in members: + remapped_ids[member_id] = aggregate_id + aggregated_nodes[aggregate_id] = replace( + first_node, + logical_id=aggregate_id, + properties={}, + label="{} x{}".format(_compact_resource_label(first_node, rules), len(members)), + ) + parent = compact_parent.get(first_node.logical_id) + if parent is not None: + aggregated_parent[aggregate_id] = parent + + for node_id, node in compact_nodes.items(): + if node_id in remapped_ids: + continue + aggregated_nodes[node_id] = replace(node, label=_compact_resource_label(node, rules)) + parent = compact_parent.get(node_id) + if parent is not None: + aggregated_parent[node_id] = parent + + remapped_attachment_labels = _remap_attachment_labels( + compact_attachment_labels, + remapped_ids, + set(aggregated_nodes), + ) + aggregated_nodes = _with_attachment_labels(aggregated_nodes, remapped_attachment_labels, rules) + remapped_edges = [ + replace( + edge, + from_id=remapped_ids.get(edge.from_id, edge.from_id), + to_id=remapped_ids.get(edge.to_id, edge.to_id), + ) + for edge in compact_edges + ] + remapped_aliases = { + source_id: remapped_ids.get(target_id, target_id) + for source_id, target_id in _normalize_endpoint_aliases(hidden_target_aliases).items() + } + return ( + compact_layers, + aggregated_nodes, + _dedupe_edges(remapped_edges), + aggregated_parent, + True, + _visible_endpoint_aliases(remapped_aliases, aggregated_nodes, compact_layers), + ) + + +def _is_compact_supported(resource: TemplateResource) -> bool: + return resource.resource_type.startswith("ALIYUN::") + + +def _foldable_overview_node_count( + nodes: dict[str, TemplateResource], + compactable_ids: set[str], + rules: ArchitectureRules, +) -> int: + child_attachment_types = { + resource_type for rule in rules.compact_child_attachments for resource_type in rule.resource_types + } + bridge_attachment_types = { + resource_type for rule in rules.compact_bridge_attachments for resource_type in rule.resource_types + } + concept_via_types = { + resource_type for rule in rules.compact_concept_nodes for resource_type in rule.via_resource_types + } + return sum( + 1 + for node_id, node in nodes.items() + if node_id in compactable_ids + and ( + node.short_type in rules.compact_hidden_short_types + or node.resource_type in rules.compact_orchestration_action_types + or node.resource_type in child_attachment_types + or node.resource_type in bridge_attachment_types + or node.resource_type in concept_via_types + ) + ) + + +def _aggregate_groups( + nodes: dict[str, TemplateResource], + edges: list[GraphEdge], + node_parent: dict[str, str], +) -> list[list[str]]: + signatures = _node_edge_signatures(nodes, edges) + buckets: dict[tuple[str, str | None, str, tuple[tuple[str, str], ...]], list[str]] = {} + for node_id, node in nodes.items(): + if not _is_compact_supported(node): + continue + key = ( + node.resource_type, + node_parent.get(node_id), + _semantic_compute_aggregate_role_key(node), + signatures.get(node_id, ()), + ) + buckets.setdefault(key, []).append(node_id) + return [members for members in buckets.values() if len(members) >= COMPACT_MIN_AGGREGATE_COUNT] + + +def _semantic_compute_aggregate_role_key(node: TemplateResource) -> str: + if node.resource_type not in SEMANTIC_COMPUTE_AGGREGATE_TYPES: + return "" + + values = [node.logical_id, node.label] + for property_name in ("InstanceName", "HostName", "Name"): + property_value = node.properties.get(property_name) + if isinstance(property_value, str): + values.append(property_value) + raw_value = " ".join(values) + normalized = _normalize_semantic_role_text(raw_value) + compacted = _compact_semantic_role_text(raw_value) + for token in SEMANTIC_COMPUTE_ROLE_TOKENS: + if token in normalized or token in compacted: + return token + return "" + + +def _normalize_semantic_role_text(value: str) -> str: + words = re.findall(r"[a-z0-9]+", re.sub(r"([a-z0-9])([A-Z])", r"\1 \2", value).lower()) + return " ".join(words) + + +def _compact_semantic_role_text(value: str) -> str: + return "".join(re.findall(r"[a-z0-9]+", value.lower())) + + +def _node_edge_signatures( + nodes: dict[str, TemplateResource], + edges: list[GraphEdge], +) -> dict[str, tuple[tuple[str, str], ...]]: + signatures: dict[str, list[tuple[str, str]]] = {node_id: [] for node_id in nodes} + for edge in edges: + if edge.from_id in signatures: + signatures[edge.from_id].append((f"out:{edge.style}:{edge.label or ''}", edge.to_id)) + if edge.to_id in signatures: + signatures[edge.to_id].append((f"in:{edge.style}:{edge.label or ''}", edge.from_id)) + return {node_id: tuple(sorted(signature)) for node_id, signature in signatures.items()} + + +def _compact_relation_fold_edges( + via_resources: dict[str, TemplateResource], + endpoint_resources: dict[str, TemplateResource], + relations: list[ResourceRelation], + rules: ArchitectureRules, +) -> tuple[list[GraphEdge], set[str], dict[str, tuple[str, ...]]]: + folded_edges: list[GraphEdge] = [] + folded_resource_ids: set[str] = set() + source_attachment_labels: dict[str, list[str]] = {} + by_source = _relations_by_source(relations) + for resource in via_resources.values(): + source_relations = by_source.get(resource.logical_id, []) + for fold in rules.compact_relation_folds: + if resource.resource_type not in fold.via_resource_types: + continue + source_id = _relation_target(source_relations, fold.source_property, endpoint_resources) + target_id = _relation_target(source_relations, fold.target_property, endpoint_resources) + if source_id is None or target_id is None: + continue + label = _localized_rule_label(fold.edge_label) or _compact_resource_label(resource, rules) + if fold.render_as == "source_attachment": + source_attachment_labels.setdefault(source_id, []).append(label) + else: + folded_edges.append( + GraphEdge( + from_id=source_id, + to_id=target_id, + style=fold.edge_style, + label=label, + ) + ) + folded_resource_ids.add(resource.logical_id) + return ( + _dedupe_edges(folded_edges), + folded_resource_ids, + {node_id: tuple(labels) for node_id, labels in source_attachment_labels.items()}, + ) + + +def _add_compact_concept_nodes( + resources: dict[str, TemplateResource], + layers: dict[str, TemplateResource], + layer_parent: dict[str, str], + nodes: dict[str, TemplateResource], + edges: list[GraphEdge], + node_parent: dict[str, str], + relations: list[ResourceRelation], + rules: ArchitectureRules, +) -> tuple[ + dict[str, TemplateResource], + dict[str, str], + dict[str, TemplateResource], + list[GraphEdge], + dict[str, str], + tuple[ConceptNodeInstance, ...], + tuple[ConceptGroupInstance, ...], +]: + if not rules.compact_concept_nodes: + return layers, layer_parent, nodes, edges, node_parent, (), () + + concept_nodes: list[ConceptNodeInstance] = [] + concept_groups: list[ConceptGroupInstance] = [] + expanded_layers = dict(layers) + expanded_layer_parent = dict(layer_parent) + expanded_nodes = dict(nodes) + expanded_edges = list(edges) + expanded_parent = dict(node_parent) + by_source = _relations_by_source(relations) + + for via_resource in resources.values(): + source_relations = by_source.get(via_resource.logical_id, []) + for rule in rules.compact_concept_nodes: + if via_resource.resource_type not in rule.via_resource_types: + continue + controller_id = _relation_target(source_relations, rule.controller_property, expanded_nodes) + source_id = _relation_target(source_relations, rule.source_property, expanded_nodes) + if controller_id is None or source_id is None: + continue + concept_id = _unique_node_id(_safe_mermaid_id(f"{controller_id}{rule.id_suffix}"), expanded_nodes) + concept_label = _localized_rule_label(rule.label) or rule.resource_type + expanded_nodes[concept_id] = TemplateResource( + logical_id=concept_id, + resource_type=rule.resource_type, + properties={}, + meta=None, + label=concept_label, + ) + parent_id = expanded_parent.get(controller_id) + if parent_id is not None: + expanded_parent[concept_id] = parent_id + role_ids = {"controller": controller_id, "source": source_id, "concept": concept_id} + if rule.controller_edge is not None: + expanded_edges.append( + GraphEdge( + from_id=controller_id, + to_id=_concept_edge_target_id(rule.controller_edge, role_ids), + style=rule.controller_edge.style, + label=_localized_rule_label(rule.controller_edge.label), + ) + ) + if rule.source_edge is not None: + expanded_edges.append( + GraphEdge( + from_id=source_id, + to_id=_concept_edge_target_id(rule.source_edge, role_ids), + style=rule.source_edge.style, + label=_localized_rule_label(rule.source_edge.label), + ) + ) + group_id: str | None = None + if rule.group is not None: + group_id = _add_concept_group( + rule.group, + role_ids, + expanded_layers, + expanded_layer_parent, + expanded_nodes, + expanded_parent, + concept_groups, + ) + concept_nodes.append( + ConceptNodeInstance( + node_id=concept_id, + label=concept_label, + resource_type=rule.resource_type, + controller_id=controller_id, + source_id=source_id, + via_id=via_resource.logical_id, + runtime_source_id=source_id, + group_id=group_id, + ) + ) + + return ( + expanded_layers, + expanded_layer_parent, + expanded_nodes, + _dedupe_edges(expanded_edges), + expanded_parent, + tuple(concept_nodes), + tuple(concept_groups), + ) + + +def _add_ack_application_concept_nodes( + resources: dict[str, TemplateResource], + nodes: dict[str, TemplateResource], + edges: list[GraphEdge], + node_parent: dict[str, str], + relations: list[ResourceRelation], +) -> tuple[dict[str, TemplateResource], list[GraphEdge], dict[str, str]]: + cluster_categories = _ack_application_categories_by_cluster(resources, nodes, relations) + if not cluster_categories: + return nodes, edges, node_parent + + expanded_nodes = dict(nodes) + expanded_edges = list(edges) + expanded_parent = dict(node_parent) + by_source = _relations_by_source(relations) + concept_ids_by_cluster: dict[str, dict[str, str]] = {} + + for cluster_id, categories in cluster_categories.items(): + if not _should_expose_ack_application_concepts(categories): + continue + concept_ids: dict[str, str] = {} + for category in ("workload", "service", "ingress", "autoscaler"): + entries = categories.get(category) + if not entries: + continue + concept_id = _unique_node_id( + _safe_mermaid_id(f"{cluster_id}{ACK_APPLICATION_CONCEPT_SUFFIXES[category]}"), + expanded_nodes, + ) + expanded_nodes[concept_id] = TemplateResource( + logical_id=concept_id, + resource_type=ACK_APPLICATION_CONCEPT_TYPES[category], + properties={ + "cluster": cluster_id, + "category": category, + "sources": tuple(_dedupe([str(entry["source"]) for entry in entries])), + "kinds": tuple(_dedupe([str(entry["kind"]) for entry in entries])), + "names": tuple(_dedupe([str(entry["name"]) for entry in entries if entry.get("name")])), + }, + meta=None, + label=_localized_rule_label(ACK_APPLICATION_CONCEPT_LABELS[category]) + or ACK_APPLICATION_CONCEPT_TYPES[category], + ) + parent_id = expanded_parent.get(cluster_id) + if parent_id is not None: + expanded_parent[concept_id] = parent_id + concept_ids[category] = concept_id + concept_ids_by_cluster[cluster_id] = concept_ids + + if not concept_ids_by_cluster: + return nodes, edges, node_parent + + for concept_ids in concept_ids_by_cluster.values(): + ingress_id = concept_ids.get("ingress") + service_id = concept_ids.get("service") + workload_id = concept_ids.get("workload") + autoscaler_id = concept_ids.get("autoscaler") + if ingress_id is not None and service_id is not None: + expanded_edges.append( + GraphEdge( + from_id=ingress_id, + to_id=service_id, + style="solid_arrow", + label=_localized_rule_label(ACK_APPLICATION_CONCEPT_EDGE_LABELS["ingress_to_service"]), + ) + ) + if service_id is not None and workload_id is not None: + expanded_edges.append( + GraphEdge( + from_id=service_id, + to_id=workload_id, + style="solid_arrow", + label=_localized_rule_label(ACK_APPLICATION_CONCEPT_EDGE_LABELS["service_to_workload"]), + ) + ) + if autoscaler_id is not None and workload_id is not None: + expanded_edges.append( + GraphEdge( + from_id=autoscaler_id, + to_id=workload_id, + style="dotted_arrow", + label=_localized_rule_label(ACK_APPLICATION_CONCEPT_EDGE_LABELS["autoscaler_to_workload"]), + ) + ) + + for resource in resources.values(): + if resource.resource_type not in ACK_HELM_APPLICATION_TYPES: + continue + cluster_id = _relation_target(by_source.get(resource.logical_id, []), "ClusterId", nodes) + autoscaler_id = concept_ids_by_cluster.get(cluster_id or "", {}).get("autoscaler") + if autoscaler_id is None or resource.logical_id not in expanded_nodes: + continue + expanded_edges.append( + GraphEdge( + from_id=resource.logical_id, + to_id=autoscaler_id, + style="dotted_open", + label=_localized_rule_label(ACK_APPLICATION_CONCEPT_EDGE_LABELS["metrics_adapter"]), + ) + ) + + for cluster_id, categories in cluster_categories.items(): + autoscaler_id = concept_ids_by_cluster.get(cluster_id, {}).get("autoscaler") + if autoscaler_id is None: + continue + for entry in categories.get("autoscaler", ()): + for target_id in entry.get("template_refs", ()): + if target_id in expanded_nodes: + expanded_edges.append( + GraphEdge( + from_id=target_id, + to_id=autoscaler_id, + style="dotted_open", + label=_localized_rule_label(ACK_APPLICATION_CONCEPT_EDGE_LABELS["external_metrics"]), + ) + ) + + for resource in resources.values(): + if resource.resource_type not in ACK_HELM_APPLICATION_TYPES: + continue + cluster_id = _relation_target(by_source.get(resource.logical_id, []), "ClusterId", nodes) + workload_id = concept_ids_by_cluster.get(cluster_id or "", {}).get("workload") + if workload_id is None: + continue + for target_id in _extract_resource_refs(resource.properties.get("ChartValues"), expanded_nodes): + target = expanded_nodes.get(target_id) + label = _ack_application_data_dependency_label(target.resource_type if target else "") + if label is None: + continue + expanded_edges.append( + GraphEdge( + from_id=workload_id, + to_id=target_id, + style="solid_arrow", + label=label, + ) + ) + + return expanded_nodes, _dedupe_edges(expanded_edges), expanded_parent + + +def _ack_application_categories_by_cluster( + resources: dict[str, TemplateResource], + visible_nodes: dict[str, TemplateResource], + relations: list[ResourceRelation], +) -> dict[str, dict[str, tuple[dict[str, Any], ...]]]: + by_source = _relations_by_source(relations) + categories_by_cluster: dict[str, dict[str, list[dict[str, Any]]]] = {} + for resource in resources.values(): + if resource.resource_type != ACK_CLUSTER_APPLICATION_TYPE: + continue + cluster_id = _relation_target(by_source.get(resource.logical_id, []), "ClusterId", visible_nodes) + if cluster_id is None: + continue + for entry in _ack_cluster_application_manifest_entries(resource, resources, include_documents=True): + category = _ack_application_concept_category(str(entry["kind"])) + if category is None: + continue + categories_by_cluster.setdefault(cluster_id, {}).setdefault(category, []).append( + { + "cluster": cluster_id, + **entry, + } + ) + if category == "ingress": + for service_entry in _ack_ingress_backend_service_entries(entry): + categories_by_cluster.setdefault(cluster_id, {}).setdefault("service", []).append( + { + "cluster": cluster_id, + **service_entry, + } + ) + for resource in resources.values(): + if resource.resource_type not in ACK_HELM_APPLICATION_TYPES: + continue + cluster_id = _relation_target(by_source.get(resource.logical_id, []), "ClusterId", visible_nodes) + if cluster_id is None: + continue + for entry in _ack_helm_application_workload_entries(resource, resources): + categories_by_cluster.setdefault(cluster_id, {}).setdefault("workload", []).append( + { + "cluster": cluster_id, + **entry, + } + ) + return { + cluster_id: {category: tuple(entries) for category, entries in categories.items()} + for cluster_id, categories in categories_by_cluster.items() + } + + +def _ack_ingress_backend_service_entries(entry: dict[str, Any]) -> tuple[dict[str, Any], ...]: + document = entry.get("document") + if not isinstance(document, dict): + return () + service_names: list[str] = [] + for service in _find_kubernetes_ingress_backend_services(document.get("spec")): + name = service.get("name") + if isinstance(name, str) and name: + service_names.append(name) + return tuple( + { + "source": str(entry["source"]), + "kind": "Service", + "name": name, + "label": _localized_rule_label(KUBERNETES_KIND_ATTACHMENT_LABELS.get("Service")) or "Service", + "template_refs": tuple(entry.get("template_refs", ())), + } + for name in _dedupe(service_names) + ) + + +def _find_kubernetes_ingress_backend_services(value: Any) -> list[dict[str, Any]]: + services: list[dict[str, Any]] = [] + if isinstance(value, dict): + service = value.get("service") + if isinstance(service, dict): + services.append(service) + for child in value.values(): + services.extend(_find_kubernetes_ingress_backend_services(child)) + elif isinstance(value, list): + for item in value: + services.extend(_find_kubernetes_ingress_backend_services(item)) + return services + + +def _ack_helm_application_workload_entries( + resource: TemplateResource, + resources: dict[str, TemplateResource], +) -> tuple[dict[str, Any], ...]: + wait_until = resource.properties.get("WaitUntil") + if not isinstance(wait_until, list): + wait_until = [] + entries: list[dict[str, Any]] = [] + for item in wait_until: + if not isinstance(item, dict): + continue + kind = item.get("Kind") + if not isinstance(kind, str) or _ack_application_concept_category(kind) != "workload": + continue + name = item.get("Name") + entries.append( + { + "source": resource.logical_id, + "kind": kind, + "name": name if isinstance(name, str) else None, + "label": _localized_rule_label(KUBERNETES_KIND_ATTACHMENT_LABELS.get(kind)) + or _localized_rule_label(ACK_APPLICATION_CONCEPT_LABELS["workload"]) + or kind, + "template_refs": _extract_resource_refs(resource.properties.get("ChartValues"), resources), + } + ) + if entries: + return tuple(entries) + release_name = resource.properties.get("ReleaseName") + if isinstance(release_name, str) and release_name: + return ( + { + "source": resource.logical_id, + "kind": "Deployment", + "name": release_name, + "label": _localized_rule_label(KUBERNETES_KIND_ATTACHMENT_LABELS.get("Deployment")) + or _localized_rule_label(ACK_APPLICATION_CONCEPT_LABELS["workload"]) + or "Deployment", + "template_refs": _extract_resource_refs(resource.properties.get("ChartValues"), resources), + }, + ) + return () + + +def _should_expose_ack_application_concepts(categories: dict[str, tuple[dict[str, Any], ...]]) -> bool: + semantic_categories = {"workload", "service", "ingress", "autoscaler"} + present = semantic_categories.intersection(category for category, entries in categories.items() if entries) + return len(present) >= 2 or "autoscaler" in present + + +def _ack_application_concept_category(kind: str) -> str | None: + if kind in ACK_WORKLOAD_KINDS: + return "workload" + if kind in ACK_SERVICE_KINDS: + return "service" + if kind in ACK_INGRESS_KINDS: + return "ingress" + if kind in ACK_AUTOSCALER_KINDS: + return "autoscaler" + return None + + +def _ack_application_data_dependency_label(resource_type: str) -> str | None: + if "REDIS::" in resource_type: + return _localized_rule_label(ACK_APPLICATION_CONCEPT_EDGE_LABELS["cache_access"]) + if "GPDB::" in resource_type or "ADB" in resource_type or "AnalyticDB" in resource_type: + return _localized_rule_label(ACK_APPLICATION_CONCEPT_EDGE_LABELS["vector_search"]) + if ( + "RDS::" in resource_type + or "POLARDB::" in resource_type + or "MongoDB::" in resource_type + or "DRDS::" in resource_type + or "DBInstance" in resource_type + ): + return _localized_rule_label(ACK_APPLICATION_CONCEPT_EDGE_LABELS["database_access"]) + if "OSS::" in resource_type or "NAS::" in resource_type: + return _localized_rule_label(ACK_APPLICATION_CONCEPT_EDGE_LABELS["data_dependency"]) + return None + + +def _concept_edge_target_id(edge: ConceptEdgeRule, role_ids: dict[str, str]) -> str: + return role_ids.get(edge.target, role_ids["concept"]) + + +def _add_concept_group( + group_rule: CompactConceptGroup, + role_ids: dict[str, str], + layers: dict[str, TemplateResource], + layer_parent: dict[str, str], + nodes: dict[str, TemplateResource], + node_parent: dict[str, str], + concept_groups: list[ConceptGroupInstance], +) -> str | None: + member_ids = tuple(_dedupe([role_ids[role] for role in group_rule.members if role in role_ids])) + if len(member_ids) < 2: + return None + parent_ids = {node_parent.get(member_id) for member_id in member_ids} + if len(parent_ids) != 1: + return None + group_id = _unique_layer_id(_safe_mermaid_id(f"{role_ids['controller']}{group_rule.id_suffix}"), layers, nodes) + group_label = _localized_rule_label(group_rule.label) or group_rule.resource_type + layers[group_id] = TemplateResource( + logical_id=group_id, + resource_type=group_rule.resource_type, + properties={}, + meta=None, + label=group_label, + ) + parent_id = next(iter(parent_ids)) + if parent_id is not None: + layer_parent[group_id] = parent_id + for member_id in member_ids: + node_parent[member_id] = group_id + concept_groups.append( + ConceptGroupInstance( + group_id=group_id, + label=group_label, + resource_type=group_rule.resource_type, + member_ids=member_ids, + rewrite_edge_kinds=group_rule.rewrite_edge_kinds, + parent_id=parent_id, + ) + ) + return group_id + + +def _unique_layer_id( + base_id: str, + layers: dict[str, TemplateResource], + nodes: dict[str, TemplateResource], +) -> str: + if base_id not in layers and base_id not in nodes: + return base_id + index = 2 + while f"{base_id}{index}" in layers or f"{base_id}{index}" in nodes: + index += 1 + return f"{base_id}{index}" + + +def _unique_node_id(base_id: str, nodes: dict[str, TemplateResource]) -> str: + if base_id not in nodes: + return base_id + index = 2 + while f"{base_id}{index}" in nodes: + index += 1 + return f"{base_id}{index}" + + +def _relation_target( + relations: list[ResourceRelation], + property_name: str, + resources: dict[str, TemplateResource], +) -> str | None: + for relation in relations: + if relation.property_name == property_name and relation.target_id in resources: + return relation.target_id + return None + + +def _relation_targets( + relations: list[ResourceRelation], + property_names: tuple[str, ...], + nodes: dict[str, TemplateResource], + target_types: tuple[str, ...] = (), +) -> tuple[str, ...]: + property_name_set = set(property_names) + target_type_set = set(target_types) + targets: list[str] = [] + for relation in relations: + if relation.property_name not in property_name_set or relation.target_id not in nodes: + continue + if target_type_set and nodes[relation.target_id].resource_type not in target_type_set: + continue + targets.append(relation.target_id) + return tuple(_dedupe(targets)) + + +def _compact_attachment_labels( + nodes: dict[str, TemplateResource], + auxiliary: dict[str, TemplateResource], + relations: list[ResourceRelation], + rules: ArchitectureRules, +) -> tuple[dict[str, tuple[str, ...]], set[str], dict[str, tuple[str, ...]]]: + labels: dict[str, list[str]] = {} + attached_marker_ids: set[str] = set() + attachment_targets: dict[str, list[str]] = {} + by_source = _relations_by_source(relations) + for resource in auxiliary.values(): + source_relations = by_source.get(resource.logical_id, []) + main_ref = _main_resource_ref(resource, source_relations) + if main_ref is None or main_ref not in nodes: + continue + main_resource = nodes[main_ref] + if not _is_compact_attachment_marker(main_resource, rules): + continue + target_ids = _dedupe( + [ + relation.target_id + for relation in source_relations + if relation.target_id != main_ref and relation.target_id in nodes + ] + ) + if not target_ids: + continue + marker_label = _compact_resource_label(main_resource, rules) + for target_id in target_ids: + labels.setdefault(target_id, []).append(marker_label) + attachment_targets.setdefault(main_ref, []).append(target_id) + attached_marker_ids.add(main_ref) + return ( + {node_id: tuple(node_labels) for node_id, node_labels in labels.items()}, + attached_marker_ids, + {node_id: tuple(_dedupe(target_ids)) for node_id, target_ids in attachment_targets.items()}, + ) + + +def _propagate_attachment_labels( + attachment_labels: dict[str, tuple[str, ...]], + attachment_targets: dict[str, tuple[str, ...]], +) -> dict[str, tuple[str, ...]]: + propagated: dict[str, list[str]] = {} + for node_id, labels in attachment_labels.items(): + for target_id in _ultimate_attachment_targets(node_id, attachment_targets): + propagated.setdefault(target_id, []).extend(labels) + return {node_id: tuple(labels) for node_id, labels in propagated.items()} + + +def _ultimate_attachment_targets( + node_id: str, + attachment_targets: dict[str, tuple[str, ...]], + seen: frozenset[str] = frozenset(), +) -> tuple[str, ...]: + if node_id in seen or node_id not in attachment_targets: + return (node_id,) + targets: list[str] = [] + for target_id in attachment_targets[node_id]: + targets.extend(_ultimate_attachment_targets(target_id, attachment_targets, seen | {node_id})) + return tuple(_dedupe(targets)) + + +def _compact_attachment_edges( + nodes: dict[str, TemplateResource], + relations: list[ResourceRelation], + attachment_targets: dict[str, tuple[str, ...]], + rules: ArchitectureRules, +) -> list[GraphEdge]: + if not rules.compact_attachment_edges: + return [] + edges: list[GraphEdge] = [] + by_source = _relations_by_source(relations) + for node in nodes.values(): + source_relations = by_source.get(node.logical_id, []) + for rule in rules.compact_attachment_edges: + if node.resource_type not in rule.resource_types: + continue + edges.extend(_compact_attachment_edges_for_rule(source_relations, nodes, attachment_targets, rule)) + return _dedupe_edges(edges) + + +def _compact_attachment_edges_for_rule( + relations: list[ResourceRelation], + nodes: dict[str, TemplateResource], + attachment_targets: dict[str, tuple[str, ...]], + rule: CompactAttachmentEdge, +) -> list[GraphEdge]: + source_ids = _relation_targets(relations, rule.source_properties, nodes, rule.source_types) + marker_ids = _relation_targets(relations, rule.marker_properties, nodes, rule.marker_types) + if not source_ids or not marker_ids: + return [] + label = _localized_rule_label(rule.edge_label) + edges: list[GraphEdge] = [] + for source_id in source_ids: + for marker_id in marker_ids: + for target_id in _ultimate_attachment_targets(marker_id, attachment_targets): + if target_id not in nodes: + continue + edges.append(GraphEdge(from_id=source_id, to_id=target_id, style=rule.edge_style, label=label)) + return edges + + +def _compact_child_attachment_labels( + resources: dict[str, TemplateResource], + target_resources: dict[str, TemplateResource], + relations: list[ResourceRelation], + rules: ArchitectureRules, +) -> tuple[dict[str, tuple[str, ...]], set[str], dict[str, str]]: + labels: dict[str, list[str]] = {} + child_ids: set[str] = set() + attachment_targets: dict[str, str] = {} + by_source = _relations_by_source(relations) + for resource in resources.values(): + source_relations = by_source.get(resource.logical_id, []) + if _has_compact_marker_main_resource(resource, source_relations, target_resources, rules): + continue + for rule in rules.compact_child_attachments: + if resource.resource_type not in rule.resource_types: + continue + if ( + _is_auxiliary(resource, rules) + and _is_compact_bridge_via_resource(resource, rules) + and not rule.keep_when_bridge_via + ): + continue + target_id = _child_attachment_target( + source_relations, target_resources, rule.target_properties, rule.target_types + ) + if target_id is None: + continue + labels.setdefault(target_id, []).extend(_compact_child_attachment_marker_labels(resource, rule, rules)) + child_ids.add(resource.logical_id) + attachment_targets[resource.logical_id] = target_id + break + return {node_id: tuple(node_labels) for node_id, node_labels in labels.items()}, child_ids, attachment_targets + + +def _compact_child_attachment_marker_labels( + resource: TemplateResource, + rule: Any, + rules: ArchitectureRules, +) -> tuple[str, ...]: + if resource.resource_type == ACK_CLUSTER_APPLICATION_TYPE: + manifest_labels = _ack_cluster_application_manifest_labels(resource) + if manifest_labels: + return manifest_labels + return (_localized_rule_label(rule.label) or _compact_resource_label(resource, rules),) + + +def _ack_cluster_application_manifest_labels(resource: TemplateResource) -> tuple[str, ...]: + labels: list[str] = [] + for entry in _ack_cluster_application_manifest_entries(resource, {}): + kind = str(entry["kind"]) + rule_label = KUBERNETES_KIND_ATTACHMENT_LABELS.get(kind) + label = _localized_rule_label(rule_label) if rule_label is not None else kind + labels.append(label or kind) + return tuple(label for label in labels if label) + + +def _ack_application_context( + resources: dict[str, TemplateResource], + relations: list[ResourceRelation], +) -> list[dict[str, Any]]: + by_source = _relations_by_source(relations) + context: list[dict[str, Any]] = [] + for resource in resources.values(): + if resource.resource_type != ACK_CLUSTER_APPLICATION_TYPE: + continue + cluster_id = _relation_target(by_source.get(resource.logical_id, []), "ClusterId", resources) + for entry in _ack_cluster_application_manifest_entries(resource, resources): + context.append({"cluster": cluster_id, **entry}) + for resource in resources.values(): + if resource.resource_type not in ACK_HELM_APPLICATION_TYPES: + continue + cluster_id = _relation_target(by_source.get(resource.logical_id, []), "ClusterId", resources) + for entry in _ack_helm_application_workload_entries(resource, resources): + context.append({"cluster": cluster_id, **entry}) + return context + + +def _ack_cluster_application_manifest_entries( + resource: TemplateResource, + resources: dict[str, TemplateResource], + *, + include_documents: bool = False, +) -> tuple[dict[str, Any], ...]: + yaml_content = _ros_string_value(resource.properties.get("YamlContent")) + if yaml_content is None: + return () + entries: list[dict[str, Any]] = [] + template_refs = _extract_template_refs_from_text(yaml_content, resources) + for document in _kubernetes_manifest_documents(yaml_content): + kind = document.get("kind") + if not isinstance(kind, str) or not kind: + continue + rule_label = KUBERNETES_KIND_ATTACHMENT_LABELS.get(kind) + metadata = document.get("metadata") if isinstance(document.get("metadata"), dict) else {} + name = metadata.get("name") if isinstance(metadata, dict) else None + entry: dict[str, Any] = { + "source": resource.logical_id, + "kind": kind, + "name": name if isinstance(name, str) else None, + "label": _localized_rule_label(rule_label) if rule_label is not None else kind, + "template_refs": template_refs, + } + if include_documents: + entry["document"] = document + entries.append(entry) + return tuple(entries) + + +def _kubernetes_manifest_documents(yaml_content: str) -> tuple[dict[str, Any], ...]: + documents: list[dict[str, Any]] = [] + try: + for document in yaml.safe_load_all(yaml_content): + if isinstance(document, dict): + documents.append(document) + except yaml.YAMLError: + return () + return tuple(documents) + + +def _extract_template_refs_from_text(text: str, resources: dict[str, TemplateResource]) -> list[str]: + if not resources: + return [] + refs: list[str] = [] + for match in re.finditer(r"\$\{([A-Za-z][A-Za-z0-9_]*)(?:[.][^}]*)?\}", text): + resource_id = match.group(1) + if resource_id in resources: + refs.append(resource_id) + return _dedupe(refs) + + +def _ros_string_value(value: Any) -> str | None: + if isinstance(value, str): + return value + if isinstance(value, dict): + fn_sub = value.get("Fn::Sub") + if isinstance(fn_sub, str): + return fn_sub + if isinstance(fn_sub, list) and fn_sub and isinstance(fn_sub[0], str): + return fn_sub[0] + fn_join = value.get("Fn::Join") + if isinstance(fn_join, list) and len(fn_join) >= 2: + delimiter = fn_join[0] if isinstance(fn_join[0], str) else "" + if not isinstance(fn_join[1], list): + return None + parts = [_ros_string_value(item) for item in fn_join[1]] + joined = delimiter.join(part for part in parts if part is not None) + return joined or None + return None + + +def _kubernetes_manifest_kinds(yaml_content: str) -> tuple[str, ...]: + return tuple( + str(document["kind"]) for document in _kubernetes_manifest_documents(yaml_content) if document.get("kind") + ) + + +def _filter_unresolved_child_attachments( + attachment_labels: dict[str, tuple[str, ...]], + child_ids: set[str], + attachment_targets: dict[str, str], + visible_target_ids: set[str], +) -> tuple[dict[str, tuple[str, ...]], set[str], dict[str, str]]: + if not attachment_targets: + return attachment_labels, child_ids, attachment_targets + + normalized_targets = _normalize_endpoint_aliases(attachment_targets) + resolved_source_ids = { + source_id for source_id, target_id in normalized_targets.items() if target_id in visible_target_ids + } + filtered_labels = { + target_id: labels + for target_id, labels in attachment_labels.items() + if target_id in visible_target_ids or target_id in resolved_source_ids + } + return ( + filtered_labels, + child_ids & resolved_source_ids, + { + source_id: target_id + for source_id, target_id in attachment_targets.items() + if source_id in resolved_source_ids + }, + ) + + +def _has_compact_marker_main_resource( + resource: TemplateResource, + relations: list[ResourceRelation], + target_resources: dict[str, TemplateResource], + rules: ArchitectureRules, +) -> bool: + main_ref = _main_resource_ref(resource, relations) + if main_ref is None: + return False + main_resource = target_resources.get(main_ref) + return main_resource is not None and _is_compact_attachment_marker(main_resource, rules) + + +def _is_compact_bridge_via_resource(resource: TemplateResource, rules: ArchitectureRules) -> bool: + return any(resource.resource_type in rule.via_resource_types for rule in rules.compact_bridge_attachments) + + +def _compact_bridge_attachment_labels( + nodes: dict[str, TemplateResource], + target_resources: dict[str, TemplateResource], + via_resources: dict[str, TemplateResource], + relations: list[ResourceRelation], + rules: ArchitectureRules, +) -> tuple[dict[str, tuple[str, ...]], set[str], dict[str, str]]: + labels: dict[str, list[str]] = {} + child_ids: set[str] = set() + attachment_targets: dict[str, str] = {} + by_source = _relations_by_source(relations) + for node in nodes.values(): + source_relations = by_source.get(node.logical_id, []) + for rule in rules.compact_bridge_attachments: + if node.resource_type not in rule.resource_types: + continue + source_ids = _bridge_source_ids(node.logical_id, source_relations, rule.source_properties, nodes) + target_id = _bridge_attachment_target(source_ids, target_resources, via_resources, by_source, rule) + if target_id is None: + continue + labels.setdefault(target_id, []).append( + _localized_rule_label(rule.label) or _compact_resource_label(node, rules) + ) + child_ids.add(node.logical_id) + attachment_targets[node.logical_id] = target_id + break + return {node_id: tuple(node_labels) for node_id, node_labels in labels.items()}, child_ids, attachment_targets + + +def _bridge_source_ids( + node_id: str, + relations: list[ResourceRelation], + property_names: tuple[str, ...], + nodes: dict[str, TemplateResource], +) -> tuple[str, ...]: + if not property_names: + return (node_id,) + property_name_set = set(property_names) + return tuple( + _dedupe( + [ + relation.target_id + for relation in relations + if relation.property_name in property_name_set and relation.target_id in nodes + ] + ) + ) + + +def _bridge_attachment_target( + source_ids: tuple[str, ...], + target_resources: dict[str, TemplateResource], + via_resources: dict[str, TemplateResource], + relations_by_source: dict[str, list[ResourceRelation]], + rule: CompactBridgeAttachment, +) -> str | None: + if not source_ids: + return None + source_id_set = set(source_ids) + via_type_set = set(rule.via_resource_types) + via_source_property_set = set(rule.via_source_properties) + for via_node in via_resources.values(): + if via_node.resource_type not in via_type_set: + continue + via_relations = relations_by_source.get(via_node.logical_id, []) + if not any( + relation.property_name in via_source_property_set and relation.target_id in source_id_set + for relation in via_relations + ): + continue + if rule.target_self and via_node.resource_type in set(rule.target_types): + return via_node.logical_id + target_id = _child_attachment_target( + via_relations, + target_resources, + rule.via_target_properties, + rule.target_types, + ) + if target_id is not None: + return target_id + return None + + +def _child_attachment_target( + relations: list[ResourceRelation], + nodes: dict[str, TemplateResource], + property_names: tuple[str, ...], + target_types: tuple[str, ...], +) -> str | None: + target_type_set = set(target_types) + property_name_set = set(property_names) + for relation in relations: + if relation.property_name not in property_name_set or relation.target_id not in nodes: + continue + if target_type_set and nodes[relation.target_id].resource_type not in target_type_set: + continue + return relation.target_id + return None + + +def _is_compact_attachment_marker(resource: TemplateResource, rules: ArchitectureRules) -> bool: + return resource.resource_type in rules.compact_attachment_marker_types + + +def _merge_attachment_labels( + *attachment_label_groups: dict[str, tuple[str, ...]], +) -> dict[str, tuple[str, ...]]: + merged: dict[str, list[str]] = {} + for attachment_labels in attachment_label_groups: + for node_id, labels in attachment_labels.items(): + merged.setdefault(node_id, []).extend(labels) + return {node_id: tuple(labels) for node_id, labels in merged.items()} + + +def _propagate_hidden_attachment_labels( + attachment_labels: dict[str, tuple[str, ...]], + endpoint_aliases: dict[str, str], +) -> dict[str, tuple[str, ...]]: + if not endpoint_aliases: + return attachment_labels + propagated: dict[str, list[str]] = {} + normalized_aliases = _normalize_endpoint_aliases(endpoint_aliases) + for node_id, labels in attachment_labels.items(): + propagated.setdefault(normalized_aliases.get(node_id, node_id), []).extend(labels) + return {node_id: tuple(labels) for node_id, labels in propagated.items()} + + +def _normalize_endpoint_aliases(endpoint_aliases: dict[str, str]) -> dict[str, str]: + return {source_id: _ultimate_endpoint_alias_target(source_id, endpoint_aliases) for source_id in endpoint_aliases} + + +def _ultimate_endpoint_alias_target( + source_id: str, + endpoint_aliases: dict[str, str], + seen: frozenset[str] = frozenset(), +) -> str: + target_id = endpoint_aliases.get(source_id) + if target_id is None or target_id in seen: + return source_id + return _ultimate_endpoint_alias_target(target_id, endpoint_aliases, seen | {source_id}) + + +def _visible_endpoint_aliases( + endpoint_aliases: dict[str, str], + nodes: dict[str, TemplateResource], + layers: dict[str, TemplateResource], +) -> dict[str, str]: + visible_ids = set(nodes) | set(layers) + return { + source_id: target_id + for source_id, target_id in _normalize_endpoint_aliases(endpoint_aliases).items() + if source_id not in visible_ids and target_id in visible_ids + } + + +def _with_compact_labels( + nodes: dict[str, TemplateResource], + rules: ArchitectureRules, + attachment_labels: dict[str, tuple[str, ...]] | None = None, +) -> dict[str, TemplateResource]: + compact_nodes = { + node_id: replace(node, label=_compact_resource_label(node, rules)) for node_id, node in nodes.items() + } + return _with_attachment_labels(compact_nodes, attachment_labels or {}, rules) + + +def _with_attachment_labels( + nodes: dict[str, TemplateResource], + attachment_labels: dict[str, tuple[str, ...]], + rules: ArchitectureRules, +) -> dict[str, TemplateResource]: + return { + node_id: _with_attachment_label(node, attachment_labels.get(node_id, ()), rules) + for node_id, node in nodes.items() + } + + +def _with_attachment_label( + resource: TemplateResource, + labels: tuple[str, ...], + rules: ArchitectureRules, +) -> TemplateResource: + formatted_labels = _format_attachment_labels(labels, rules) + if not formatted_labels: + return resource + return replace(resource, label="{}\\n{}".format(resource.label, "\\n".join(formatted_labels))) + + +def _add_layer_attachment_summary_nodes( + nodes: dict[str, TemplateResource], + node_parent: dict[str, str], + layer_attachment_labels: dict[str, tuple[str, ...]], + layers: dict[str, TemplateResource], + rules: ArchitectureRules, +) -> tuple[dict[str, TemplateResource], dict[str, str], dict[str, str]]: + if not layer_attachment_labels: + return nodes, node_parent, {} + + updated_nodes = dict(nodes) + updated_parent = dict(node_parent) + layer_summary_ids: dict[str, str] = {} + for layer_id, labels in layer_attachment_labels.items(): + formatted_labels = _format_attachment_labels(labels, rules) + if not formatted_labels or layer_id not in layers: + continue + summary_id = _layer_attachment_summary_node_id(layer_id) + layer_summary_ids[layer_id] = summary_id + updated_nodes[summary_id] = TemplateResource( + logical_id=summary_id, + resource_type=LAYER_ATTACHMENT_SUMMARY_TYPE, + properties={}, + meta=None, + label=_layer_attachment_summary_label(layers[layer_id], formatted_labels, rules), + ) + updated_parent[summary_id] = layer_id + return updated_nodes, updated_parent, layer_summary_ids + + +def _layer_attachment_summary_node_id(layer_id: str) -> str: + return _safe_mermaid_id(f"layer_{layer_id}_Config") + + +def _layer_attachment_summary_label( + layer: TemplateResource, + formatted_labels: list[str], + rules: ArchitectureRules, +) -> str: + layer_label = _localized_layer_type_label(layer, rules) + suffix = "配置" if get_current_language() == "zh" else "configuration" + return "{} {}\\n{}".format(layer_label, suffix, "\\n".join(formatted_labels)) + + +def _localized_layer_type_label(layer: TemplateResource, rules: ArchitectureRules) -> str: + base_label = layer.label.split("\\n", 1)[0] + return _(rules.legacy_layer_labels.get(layer.resource_type, base_label)) + + +def _retarget_layer_edge_endpoints( + edges: list[GraphEdge], + layer_summary_ids: dict[str, str], +) -> list[GraphEdge]: + return [ + replace( + edge, + from_id=layer_summary_ids.get(edge.from_id, edge.from_id), + to_id=layer_summary_ids.get(edge.to_id, edge.to_id), + ) + for edge in edges + ] + + +def _retarget_endpoint_aliases( + endpoint_aliases: dict[str, str], + layer_summary_ids: dict[str, str], +) -> dict[str, str]: + return {source_id: layer_summary_ids.get(target_id, target_id) for source_id, target_id in endpoint_aliases.items()} + + +def _format_attachment_labels(labels: tuple[str, ...], rules: ArchitectureRules) -> list[str]: + counts = Counter(labels) + formatted: list[str] = [] + seen: set[str] = set() + for label in labels: + if label in seen: + continue + seen.add(label) + count = counts[label] + marker = f"{label} x{count}" if count > 1 else label + formatted.append(f"{rules.attachment_label_prefix}{marker}") + return formatted + + +def _remap_attachment_labels( + attachment_labels: dict[str, tuple[str, ...]], + remapped_ids: dict[str, str], + node_ids: set[str], +) -> dict[str, tuple[str, ...]]: + remapped: dict[str, list[str]] = {} + for node_id, labels in attachment_labels.items(): + remapped_id = remapped_ids.get(node_id, node_id) + if remapped_id in node_ids: + remapped.setdefault(remapped_id, []).extend(labels) + return {node_id: tuple(labels) for node_id, labels in remapped.items()} + + +def _compact_resource_label(resource: TemplateResource, rules: ArchitectureRules) -> str: + label = rules.compact_resource_labels.get(resource.resource_type) + if label is None: + return resource.label + translated = _(label) + if get_current_language() == "zh" and translated == label: + meta_label = _localized_meta_label(resource.meta) + if meta_label is not None: + return meta_label + return translated + + +def _aggregate_node_id(resource_type: str, parent_id: str | None, role_key: str = "") -> str: + parts = resource_type.split("::") + type_key = "_".join(parts[1:]) if len(parts) > 1 else resource_type + role_part = f"_{role_key}" if role_key else "" + parent_key = f"layer_{parent_id}" if parent_id is not None else "root" + return _safe_mermaid_id(f"agg_{type_key}{role_part}_{parent_key}") + + +def _safe_mermaid_id(value: str) -> str: + return "".join(char if char.isalnum() else "_" for char in value).strip("_") + + +def _flatten_compact_layers( + layers: dict[str, TemplateResource], + layer_parent: dict[str, str], + nodes: dict[str, TemplateResource], + node_parent: dict[str, str], + relations: list[ResourceRelation], + rules: ArchitectureRules, +) -> tuple[dict[str, TemplateResource], dict[str, str], dict[str, TemplateResource], dict[str, str]]: + flatten_layer_types = { + resource_type for role in rules.compact_flatten_layer_roles for resource_type in rules.containment_types(role) + } + flatten_layer_ids = {layer_id for layer_id, layer in layers.items() if layer.resource_type in flatten_layer_types} + if not flatten_layer_ids: + return layers, layer_parent, nodes, node_parent + + flattened_layers = {layer_id: layer for layer_id, layer in layers.items() if layer_id not in flatten_layer_ids} + flattened_layer_parent: dict[str, str] = {} + for layer_id, parent_id in layer_parent.items(): + if layer_id not in flattened_layers: + continue + visible_parent_id = _visible_layer_parent(parent_id, flatten_layer_ids, layer_parent) + if visible_parent_id is not None and visible_parent_id in flattened_layers: + flattened_layer_parent[layer_id] = visible_parent_id + + flattened_node_parent: dict[str, str] = {} + attachment_labels: dict[str, list[str]] = {} + for node_id, parent_id in node_parent.items(): + hidden_parent_ids = _hidden_layer_targets(node_id, relations, flatten_layer_ids) + if parent_id in flatten_layer_ids and parent_id not in hidden_parent_ids: + hidden_parent_ids.append(parent_id) + for hidden_parent_id in hidden_parent_ids: + attachment_labels.setdefault(node_id, []).append(_layer_marker_label(layers[hidden_parent_id], rules)) + visible_parent_id = ( + _direct_visible_layer_parent(node_id, layers, flatten_layer_ids, relations, rules) + if hidden_parent_ids + else _visible_layer_parent(parent_id, flatten_layer_ids, layer_parent) + ) + if visible_parent_id is None: + visible_parent_id = _visible_layer_parent(parent_id, flatten_layer_ids, layer_parent) + if visible_parent_id is not None and visible_parent_id in flattened_layers: + flattened_node_parent[node_id] = visible_parent_id + + flattened_nodes = _with_attachment_labels( + nodes, + {node_id: tuple(labels) for node_id, labels in attachment_labels.items()}, + rules, + ) + return flattened_layers, flattened_layer_parent, flattened_nodes, flattened_node_parent + + +def _hidden_layer_targets( + node_id: str, + relations: list[ResourceRelation], + hidden_layer_ids: set[str], +) -> list[str]: + return _dedupe( + [ + relation.target_id + for relation in relations + if relation.source_id == node_id and relation.target_id in hidden_layer_ids + ] + ) + + +def _direct_visible_layer_parent( + node_id: str, + layers: dict[str, TemplateResource], + hidden_layer_ids: set[str], + relations: list[ResourceRelation], + rules: ArchitectureRules, +) -> str | None: + visible_layers = {layer_id: layer for layer_id, layer in layers.items() if layer_id not in hidden_layer_ids} + for resource_types in _containment_type_priority(rules): + target_id = _first_target(node_id, relations, candidates=_ids_by_type(visible_layers, resource_types)) + if target_id is not None: + return target_id + return None + + +def _containment_type_priority(rules: ArchitectureRules) -> list[set[str]]: + return [set(resource_types) for resource_types in reversed(tuple(rules.containment_layer_types.values()))] + + +def _visible_layer_parent( + layer_id: str | None, + hidden_layer_ids: set[str], + layer_parent: dict[str, str], +) -> str | None: + while layer_id in hidden_layer_ids: + layer_id = layer_parent.get(layer_id) + return layer_id + + +def _layer_marker_label(layer: TemplateResource, rules: ArchitectureRules) -> str: + return _(rules.legacy_layer_labels.get(layer.resource_type, layer.label)) + + +def _build_containment( + layers: dict[str, TemplateResource], + nodes: dict[str, TemplateResource], + relations: list[ResourceRelation], + rules: ArchitectureRules, +) -> tuple[dict[str, str], dict[str, str]]: + layer_parent: dict[str, str] = {} + vpc_layer_types = set(rules.containment_types("vpc")) + vswitch_layer_types = set(rules.containment_types("vswitch")) + security_group_layer_types = set(rules.containment_types("security_group")) + core_layer_types = vpc_layer_types | vswitch_layer_types | security_group_layer_types + vpc_layer_ids = _ids_by_type(layers, vpc_layer_types) + vswitch_layer_ids = _ids_by_type(layers, vswitch_layer_types) + security_group_layer_ids = _ids_by_type(layers, security_group_layer_types) + + for layer_id, layer in layers.items(): + if layer.resource_type not in vswitch_layer_types: + continue + vpc_ref = _first_target(layer_id, relations, candidates=vpc_layer_ids) + if vpc_ref is not None: + layer_parent[layer_id] = vpc_ref + + for layer_id, layer in layers.items(): + if layer.resource_type not in security_group_layer_types: + continue + member_vswitches: set[str] = set() + for node_id in nodes: + if not _first_target(node_id, relations, candidates={layer_id}): + continue + vswitch_id = _first_target(node_id, relations, candidates=vswitch_layer_ids) + if vswitch_id is not None: + member_vswitches.add(vswitch_id) + if len(member_vswitches) == 1: + layer_parent[layer_id] = next(iter(member_vswitches)) + continue + vpc_ref = _first_target(layer_id, relations, candidates=vpc_layer_ids) + if vpc_ref is not None: + layer_parent[layer_id] = vpc_ref + + for layer_id, layer in layers.items(): + if layer_id in layer_parent or layer.resource_type in core_layer_types: + continue + for resource_types in _containment_type_priority(rules): + candidates = _ids_by_type(layers, resource_types) - {layer_id} + target_id = _first_target(layer_id, relations, candidates=candidates) + if target_id is not None: + layer_parent[layer_id] = target_id + break + + node_parent: dict[str, str] = {} + supplemental_layer_type_sets = [ + resource_types for resource_types in _containment_type_priority(rules) if not resource_types <= core_layer_types + ] + for node_id in nodes: + parent = ( + _first_target(node_id, relations, candidates=security_group_layer_ids) + or _first_target(node_id, relations, candidates=vswitch_layer_ids) + or _first_target(node_id, relations, candidates=vpc_layer_ids) + ) + if parent is None: + for resource_types in supplemental_layer_type_sets: + parent = _first_target(node_id, relations, candidates=_ids_by_type(layers, resource_types)) + if parent is not None: + break + if parent is not None: + node_parent[node_id] = parent + + return layer_parent, node_parent + + +def _first_target( + source_id: str, + relations: list[ResourceRelation], + *, + candidates: set[str], +) -> str | None: + for relation in relations: + if relation.source_id == source_id and relation.target_id in candidates: + return relation.target_id + return None + + +def _ids_by_type(resources: dict[str, TemplateResource], resource_types: set[str]) -> set[str]: + return {logical_id for logical_id, resource in resources.items() if resource.resource_type in resource_types} + + +def _render_mermaid( + layers: dict[str, TemplateResource], + nodes: dict[str, TemplateResource], + edges: list[GraphEdge], + layer_parent: dict[str, str], + node_parent: dict[str, str], + params: dict[str, Any], + rules: ArchitectureRules, +) -> str: + lines: list[str] = ["graph TD"] + sg_style_ids: list[str] = [] + security_group_layer_types = set(rules.containment_types("security_group")) + + def layer_label(layer_id: str) -> str: + return _localized_layer_label(layers[layer_id], params, rules) + + def render_layer(layer_id: str, indent: str) -> None: + sub_id = f"layer_{layer_id}" + lines.append(f"{indent}subgraph {sub_id} [{_subgraph_label(layer_label(layer_id))}]") + if layers[layer_id].resource_type in security_group_layer_types: + sg_style_ids.append(sub_id) + for child_layer_id in layers: + if layer_parent.get(child_layer_id) == layer_id: + render_layer(child_layer_id, indent + " ") + for child_node_id in nodes: + if node_parent.get(child_node_id) == layer_id: + lines.append(f'{indent} {child_node_id}["{nodes[child_node_id].label}"]') + lines.append(f"{indent}end") + + for layer_id in layers: + if layer_id not in layer_parent: + render_layer(layer_id, " ") + + for node_id, node in nodes.items(): + if node_id not in node_parent: + lines.append(f' {node_id}["{node.label}"]') + + for edge in _dedupe_edges(edges): + from_endpoint = _mermaid_edge_endpoint(edge.from_id, nodes, layers) + to_endpoint = _mermaid_edge_endpoint(edge.to_id, nodes, layers) + if from_endpoint is not None and to_endpoint is not None: + operator = rules.edge_operator(edge.style) + if edge.label: + lines.append(f" {from_endpoint} {operator}|{_edge_label(edge.label)}| {to_endpoint}") + else: + lines.append(f" {from_endpoint} {operator} {to_endpoint}") + + for style_id in sg_style_ids: + lines.append(f" style {style_id} stroke-dasharray: 5 5") + + return "\n".join(lines) + + +def _mermaid_edge_endpoint( + endpoint_id: str, + nodes: dict[str, TemplateResource], + layers: dict[str, TemplateResource], +) -> str | None: + if endpoint_id in nodes: + return endpoint_id + if endpoint_id in layers: + return f"layer_{endpoint_id}" + return None + + +def _resolve_cidr(value: Any, params: dict[str, Any]) -> str | None: + if isinstance(value, str): + return value + if isinstance(value, dict) and "Ref" in value: + ref = value["Ref"] + if isinstance(ref, str) and ref in params and isinstance(params[ref], dict): + default = params[ref].get("Default") + if isinstance(default, str): + return default + return None + + +def _subgraph_label(value: str) -> str: + return value.replace("[", "(").replace("]", ")") + + +def _edge_label(value: str) -> str: + return value.replace("|", "/").replace("[", "(").replace("]", ")") + + +def _relations_by_source(relations: list[ResourceRelation]) -> dict[str, list[ResourceRelation]]: + by_source: dict[str, list[ResourceRelation]] = {} + for relation in relations: + by_source.setdefault(relation.source_id, []).append(relation) + return by_source + + +def _dedupe(values: list[str]) -> list[str]: + seen: set[str] = set() + deduped: list[str] = [] + for value in values: + if value not in seen: + seen.add(value) + deduped.append(value) + return deduped + + +def _dedupe_edges(values: list[GraphEdge]) -> list[GraphEdge]: + seen: set[tuple[str, str, str, str | None]] = set() + deduped: list[GraphEdge] = [] + for value in values: + key = (value.from_id, value.to_id, value.style, value.label) + if value.from_id == value.to_id or key in seen: + continue + seen.add(key) + deduped.append(value) + return deduped diff --git a/src/iac_code/pipeline/engine/architecture_meta.py b/src/iac_code/pipeline/engine/architecture_meta.py new file mode 100644 index 00000000..eb8f8e1f --- /dev/null +++ b/src/iac_code/pipeline/engine/architecture_meta.py @@ -0,0 +1,213 @@ +"""Architecture diagram metadata loaded from vendored ROS resource meta files.""" + +from __future__ import annotations + +import json +from dataclasses import dataclass +from functools import cached_property +from pathlib import Path +from typing import Any + + +def normalize_resource_type(value: Any) -> str | None: + if not isinstance(value, str) or not value: + return None + if value.startswith("ROS/"): + value = value.removeprefix("ROS/") + elif value.startswith("Terraform/"): + return None + return value if value.startswith("ALIYUN::") else None + + +def _normalize_ros_field(value: Any) -> str | None: + if not isinstance(value, str) or not value: + return None + return value.removeprefix("ROS/") + + +@dataclass(frozen=True) +class RelatedProperty: + name: str + path: tuple[str, ...] + targets: tuple[str, ...] + value_type: str | None = None + + +@dataclass(frozen=True) +class MainResourceType: + resource_type: str + ref_property: str + + +@dataclass(frozen=True) +class ResourceMeta: + resource_type: str + name_zh: str | None + name_en: str | None + product_code: str | None + category_code: str | None + related_properties: tuple[RelatedProperty, ...] + main_resource_type: MainResourceType | None + + @cached_property + def related_properties_by_name(self) -> dict[str, RelatedProperty]: + return {prop.name: prop for prop in self.related_properties} + + +@dataclass(frozen=True) +class ProductMeta: + product_code: str + ros_code: str | None + name_zh: str | None + name_en: str | None + category_code: str | None + + +class ArchitectureMetaRepository: + """Indexed view over the vendored raw architecture metadata JSON files.""" + + _default: ArchitectureMetaRepository | None = None + + def __init__( + self, + *, + resources: dict[str, ResourceMeta] | None = None, + products: dict[str, ProductMeta] | None = None, + product_categories: dict[str, str] | None = None, + ) -> None: + self._resources = resources or {} + self._products = products or {} + self._product_categories = product_categories or {} + + @classmethod + def load_default(cls) -> ArchitectureMetaRepository: + if cls._default is None: + cls._default = cls.from_directory(Path(__file__).with_name("architecture_metas")) + return cls._default + + @classmethod + def from_directory(cls, directory: Path) -> ArchitectureMetaRepository: + categories = _load_json(directory / "Categories.json") + products = _load_json(directory / "products.json") + config = _load_json(directory / "config.json") + return cls.from_raw(categories=categories, products=products, config=config) + + @classmethod + def from_raw(cls, *, categories: Any, products: Any, config: Any) -> ArchitectureMetaRepository: + product_categories = _build_product_categories(categories) + product_index = _build_products(products, product_categories) + resources = _build_resources(config, product_categories) + return cls(resources=resources, products=product_index, product_categories=product_categories) + + def get_resource(self, resource_type: str) -> ResourceMeta | None: + return self._resources.get(resource_type) + + def get_product(self, product_code: str) -> ProductMeta | None: + return self._products.get(product_code) + + def category_code_for_product(self, product_code: str) -> str | None: + return self._product_categories.get(product_code) + + +def _load_json(path: Path) -> Any: + return json.loads(path.read_text(encoding="utf-8")) + + +def _build_product_categories(categories: Any) -> dict[str, str]: + product_categories: dict[str, str] = {} + if not isinstance(categories, list): + return product_categories + for category in categories: + if not isinstance(category, dict): + continue + code = category.get("CategoryCode") + product_codes = category.get("ProductCodes") + if not isinstance(code, str) or not isinstance(product_codes, list): + continue + for product_code in product_codes: + if isinstance(product_code, str): + product_categories.setdefault(product_code, code) + return product_categories + + +def _build_products(products: Any, product_categories: dict[str, str]) -> dict[str, ProductMeta]: + product_index: dict[str, ProductMeta] = {} + if not isinstance(products, list): + return product_index + for product in products: + if not isinstance(product, dict): + continue + product_code = product.get("ProductCode") + if not isinstance(product_code, str) or product_code in product_index: + continue + name = product.get("Name") if isinstance(product.get("Name"), dict) else {} + relevant = product.get("RelevantCodes") if isinstance(product.get("RelevantCodes"), dict) else {} + product_index[product_code] = ProductMeta( + product_code=product_code, + ros_code=relevant.get("ROS") if isinstance(relevant.get("ROS"), str) else None, + name_zh=name.get("zh") if isinstance(name.get("zh"), str) else None, + name_en=name.get("en") if isinstance(name.get("en"), str) else None, + category_code=product_categories.get(product_code), + ) + return product_index + + +def _build_resources(config: Any, product_categories: dict[str, str]) -> dict[str, ResourceMeta]: + resources: dict[str, ResourceMeta] = {} + if not isinstance(config, list): + return resources + for item in config: + if not isinstance(item, dict): + continue + resource_type = normalize_resource_type((item.get("ResourceType") or {}).get("ROS")) + if resource_type is None: + continue + name = item.get("Name") if isinstance(item.get("Name"), dict) else {} + product_code = item.get("ProductCode") if isinstance(item.get("ProductCode"), str) else None + resources[resource_type] = ResourceMeta( + resource_type=resource_type, + name_zh=name.get("zh") if isinstance(name.get("zh"), str) else None, + name_en=name.get("en") if isinstance(name.get("en"), str) else None, + product_code=product_code, + category_code=product_categories.get(product_code or ""), + related_properties=tuple(_iter_related_properties(item.get("Properties"))), + main_resource_type=_build_main_resource_type(item.get("MainResourceType")), + ) + return resources + + +def _build_main_resource_type(value: Any) -> MainResourceType | None: + if not isinstance(value, dict): + return None + resource_type = normalize_resource_type(value.get("ResourceType")) + ref_property = _normalize_ros_field(value.get("RefProperty")) + if resource_type is None or ref_property is None: + return None + return MainResourceType(resource_type=resource_type, ref_property=ref_property) + + +def _iter_related_properties(properties: Any, path_prefix: tuple[str, ...] = ()) -> list[RelatedProperty]: + related: list[RelatedProperty] = [] + if not isinstance(properties, list): + return related + for prop in properties: + if not isinstance(prop, dict): + continue + name = _normalize_ros_field(prop.get("ROS")) + path = (*path_prefix, name) if name else path_prefix + targets = tuple( + target + for target in (normalize_resource_type(item.get("ResourceType")) for item in prop.get("RelatedTo", [])) + if target is not None + ) + if name and targets: + related.append( + RelatedProperty( + name=name, + path=path, + targets=targets, + value_type=prop.get("Type") if isinstance(prop.get("Type"), str) else None, + ) + ) + related.extend(_iter_related_properties(prop.get("Properties"), path)) + return related diff --git a/src/iac_code/pipeline/engine/architecture_metas/Categories.json b/src/iac_code/pipeline/engine/architecture_metas/Categories.json new file mode 100644 index 00000000..334e3ea8 --- /dev/null +++ b/src/iac_code/pipeline/engine/architecture_metas/Categories.json @@ -0,0 +1,659 @@ +[ + { + "CategoryCode": "computing", + "CategoryName": { + "zh": "计算", + "en": "Computing" + }, + "ProductCodes": [ + "acdr", + "alinux", + "anolis", + "appstreaming", + "batchcompute", + "cloudbox", + "clouddesktop", + "cloudhosting", + "cloudphone", + "computenest", + "ddh", + "eais", + "ecd", + "eci", + "ecs", + "ecsgpu", + "ehpc", + "ens", + "ess", + "fc", + "gws", + "hosting", + "sae", + "smarthosting", + "snsu", + "swas", + "vmwaresrv", + "vs", + "wtc", + "xdragon" + ] + }, + { + "CategoryCode": "container", + "CategoryName": { + "zh": "容器", + "en": "Container" + }, + "ProductCodes": [ + "acr", + "acs", + "adcp", + "cnstack", + "csk", + "eci", + "servicemesh" + ] + }, + { + "CategoryCode": "storage", + "CategoryName": { + "zh": "存储", + "en": "Storage" + }, + "ProductCodes": [ + "alidfs", + "bdrc", + "dbfs", + "disk", + "hbr", + "hcicube", + "hcs_hgw", + "hcs_mgw", + "hcs_sgw", + "hdr", + "imm", + "nas", + "oss", + "ots", + "pds", + "sls", + "vmss" + ] + }, + { + "CategoryCode": "netcdn", + "CategoryName": { + "zh": "网络与CDN", + "en": "Networking & CDN" + }, + "ProductCodes": [ + "apsara_stack_dns", + "cbn", + "cbwp", + "cdn", + "cdt", + "dcdn", + "eip", + "expressconnect", + "flowbag", + "ga", + "ipv6gateway", + "ipv6trans", + "nat", + "netana", + "ntr", + "alb", + "nlb", + "pcdn", + "privatelink", + "pvtz", + "slb", + "smartag", + "vpc", + "vpn" + ] + }, + { + "CategoryCode": "security", + "CategoryName": { + "zh": "安全", + "en": "Security" + }, + "ProductCodes": [ + "aegis", + "antppc", + "baas", + "bastionhost", + "beaver", + "cas", + "cfw", + "cloudauth", + "cloudfw", + "csas", + "dbaudit", + "ddos", + "hsm", + "idaas", + "kms", + "lvwang", + "ram", + "saf", + "sas", + "sddp", + "sos", + "waf", + "xianzhi", + "yundun" + ] + }, + { + "CategoryCode": "middleware", + "CategoryName": { + "zh": "中间件", + "en": "Middleware" + }, + "ProductCodes": [ + "acms", + "ahas", + "alikafka", + "apigateway", + "arms", + "edas", + "eventbridge", + "fnf", + "grafana", + "middleware", + "mns", + "mse", + "ons", + "prometheus", + "pts", + "servicemesh", + "sofa", + "tsmep", + "txc", + "xtrace" + ] + }, + { + "CategoryCode": "database", + "CategoryName": { + "zh": "数据库", + "en": "Database" + }, + "ProductCodes": [ + "adam", + "adb", + "ads", + "cbs", + "cddc", + "cds", + "clickhouse", + "dbes", + "dms", + "drds", + "dts", + "gds", + "gpdb", + "hbase", + "hdm", + "hitsdb", + "kvstore", + "mongodb", + "mysql", + "oceanbase", + "polarbox", + "polardb", + "postgresql", + "rds", + "selectdb", + "sqlserver", + "ocs", + "openanalytics" + ] + }, + { + "CategoryCode": "analyticscomputing", + "CategoryName": { + "zh": "大数据计算", + "en": "Analytics Computing" + }, + "ProductCodes": [ + "bcc", + "bigdatacst", + "cdp", + "datahub", + "dataphin", + "datav", + "dide", + "dlf", + "dpc", + "drp", + "elasticsearch", + "emapreduce", + "graphcompute", + "hologram", + "man", + "milvus", + "odps", + "quickbi", + "retailadvqa", + "sc" + ] + }, + { + "CategoryCode": "aiml", + "CategoryName": { + "zh": "人工智能与机器学习", + "en": "AI & Machine Learning" + }, + "ProductCodes": [ + "addrp", + "aidesign", + "aioral", + "airec", + "alimt", + "ansyscae", + "avatar", + "bccluster", + "beebot", + "bigdata", + "braincitypa", + "brainindustrial", + "ccc", + "ccs", + "cityvisual", + "dashscope", + "dashvector", + "digitalcity", + "docmind", + "eduplatform", + "ettraffic", + "genomics", + "hiknoengine", + "hivisengine", + "holowatcher", + "idrs", + "idrsservice", + "image", + "imagesearch", + "indvi", + "ioc", + "iovcc", + "ivpd", + "learn", + "multimediaai", + "nlp", + "nls", + "ocr", + "opensearch", + "opt", + "outboundbot", + "re", + "retailbot", + "robots", + "rsimganalys", + "sca", + "service_di", + "sfm", + "suavimaganaly", + "tblearning", + "tdsr", + "tingwu", + "vcs", + "viapi", + "xingchen" + ] + }, + { + "CategoryCode": "mediaservices", + "CategoryName": { + "zh": "媒体服务", + "en": "Media Services" + }, + "ProductCodes": [ + "ice", + "imp", + "live", + "mts", + "rtc", + "vod" + ] + }, + { + "CategoryCode": "entcmc", + "CategoryName": { + "zh": "企业服务与云通信", + "en": "Enterprise Services & Cloud Communication" + }, + "ProductCodes": [ + "Internetbank", + "aias", + "aiccs", + "alibababcp", + "alimail", + "aliyuncvc", + "aliyundvs", + "assettech", + "bizworks", + "cams", + "cloudgame", + "codestore", + "companyreg", + "dingdingm1s", + "dingdingms01k", + "dingtalkpro", + "dingtalkres", + "dingtalkzhy", + "directmail", + "dns", + "domain", + "dypls", + "dypns", + "dysms", + "dytns", + "dyvms", + "emas", + "energyexpert", + "finsmtengine", + "govdingtalk", + "hotfix", + "imarketing", + "linkedmall", + "miniappdev", + "mqc", + "openad", + "premiumpics", + "quickservice", + "salesforce", + "smeads", + "swcopyright", + "teambition", + "trademark", + "trstfineng", + "xgip", + "yida", + "yuanjing" + ] + }, + { + "CategoryCode": "iot", + "CategoryName": { + "zh": "物联网", + "en": "Internet of Things" + }, + "ProductCodes": [ + "aliosthings", + "campuslink", + "iiot", + "iot", + "iotedge", + "iothardware", + "iotplatform", + "livinglink", + "tmallgenie", + "tuyaiot" + ] + }, + { + "CategoryCode": "serverless", + "CategoryName": { + "zh": "Serverless", + "en": "Serverless" + }, + "ProductCodes": [ + "devs", + "eventbridge", + "fc", + "fnf", + "mns", + "sae" + ] + }, + { + "CategoryCode": "developertools", + "CategoryName": { + "zh": "开发工具", + "en": "Developer Tools" + }, + "ProductCodes": [ + "apigateway", + "bizworks", + "cloudcontrol", + "cloudplugin", + "cloudshell", + "dragonwell", + "emas", + "lingma", + "miniappdev", + "mpaas", + "nodejs", + "openapiexplorer", + "rdc", + "ros" + ] + }, + { + "CategoryCode": "migrationom", + "CategoryName": { + "zh": "迁移与运维管理", + "en": "Migration and O&M Management" + }, + "ProductCodes": [ + "actiontrail", + "advisor", + "apds", + "arms", + "bpstudio", + "cfdcdevice", + "cfdcmro", + "cfidccabin", + "cmn", + "cms", + "composer", + "config", + "dms", + "dts", + "entconsole", + "gemp", + "governance", + "grafana", + "hbr", + "ihcms", + "oos", + "prometheus", + "quotas", + "ram", + "sls", + "smc", + "xtrace" + ] + }, + { + "CategoryCode": "apsarastack", + "CategoryName": { + "zh": "专有云", + "en": "Apsara Stack" + }, + "ProductCodes": [ + "ASAPaaS", + "alimonitor", + "apsara_stack_platform", + "apsarabase", + "apsecosystem", + "asm", + "aso", + "asonline", + "asr", + "cgw", + "dcaas", + "dtcenter", + "tianjimon", + "zstack" + ] + }, + { + "CategoryCode": "tcs", + "CategoryName": { + "zh": "培训认证服务", + "en": "Training & Certification Services" + }, + "ProductCodes": [ + "alicloudcert", + "cloudercert", + "companytrain", + "consultinginternational", + "ctn", + "deliveryinternational", + "devcloud", + "offlinetraining", + "pminternational", + "tianchi", + "unitytrain", + "universitypd" + ] + }, + { + "CategoryCode": "others", + "CategoryName": { + "zh": "其他", + "en": "Others" + }, + "ProductCodes": [ + "HYXX-EIBU", + "TDSRLYJ", + "abtd", + "accs", + "acp", + "afservice", + "aitanke", + "alicc", + "aliipc", + "alilsd", + "alinvr", + "alisttysw", + "aliyunmagic", + "antconsulting", + "antdelivery", + "antoperation", + "antservice", + "aozhe", + "applications", + "archcons", + "ascsp", + "asdelivery", + "asoperation", + "bajieyanxuan", + "bigdatacons", + "bjy", + "brainhdw", + "business", + "bss", + "bwcw", + "cbdrplus", + "cloudera", + "confluent", + "consulting", + "css", + "datamidoffsv", + "datas", + "dds", + "deliver", + "devopscons", + "devopsimpl", + "dfas", + "dice", + "draas", + "erp", + "eventmanonsite", + "eventmgtservice", + "expert", + "faservice", + "fdexchange", + "finplus", + "fkjz", + "gaodefrpp", + "govcloudsvr", + "gtsdeliver", + "healthcheck", + "hrm", + "intelligents", + "invelinklic", + "iots", + "jst", + "kingdeexk", + "kryun", + "llmservice", + "lvyue", + "manages", + "manageser", + "mapengine", + "marketplace", + "migrationcons", + "mindsphere", + "morse", + "mpai", + "mpapi", + "mpapptrack", + "mpbigdata", + "mpbusinesssoftware", + "mpcampus", + "mpcz", + "mpdattendance", + "mpdcommunication", + "mpdiyweb", + "mpdmeeting", + "mpdprint", + "mpdstage", + "mpimarket", + "mpincrease", + "mpiot", + "mplightapp", + "mplloa", + "mpother", + "mpsecurity", + "mpservice", + "mpsign", + "mpsoftware", + "mpsolution", + "mptbdata", + "mpuapp", + "mpupush", + "mpweb", + "mpyunmarket", + "onlinetraining", + "openshift", + "oplus", + "partycons", + "presto", + "qdzos", + "qimai", + "riskplus", + "sapservices", + "sccadcae", + "scp", + "servicechuangxinchuangye", + "shangtangai", + "soonku", + "specialhardware", + "ssdata", + "strategiccons", + "subcontract", + "subservice", + "superapp", + "supportings", + "supportplan", + "taas", + "thirdsw", + "tianchionline", + "tidb", + "tongque", + "veno-web6", + "vmwaresddc", + "yixin", + "yonsuite", + "zhuyun", + "zzt" + ] + } +] \ No newline at end of file diff --git a/src/iac_code/pipeline/engine/architecture_metas/config.json b/src/iac_code/pipeline/engine/architecture_metas/config.json new file mode 100644 index 00000000..65345244 --- /dev/null +++ b/src/iac_code/pipeline/engine/architecture_metas/config.json @@ -0,0 +1,107776 @@ +[ + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::Activation", + "Terraform": "alicloud_ecs_activation" + }, + "ProductCode": "ecs", + "Name": { + "zh": "ECS激活码", + "en": "ECS Activation Code" + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "InstanceCount", + "Terraform": "instance_count", + "Required": false + }, + { + "ROS": "InstanceName", + "Terraform": "instance_name", + "Required": false + }, + { + "ROS": "IpAddressRange", + "Terraform": "ip_address_range", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "TimeToLiveInHours", + "Terraform": "time_to_live_in_hours", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "ActivationCode", + "Terraform": null + }, + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": "DeregisteredCount", + "Terraform": null + }, + { + "ROS": "ActivationId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "RegisteredCount", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::AssignIpv6Addresses", + "Terraform": null + }, + "ProductCode": "ecs", + "Name": { + "zh": "IPv6地址", + "en": "IPv6 Addresses" + }, + "Properties": [ + { + "ROS": "Ipv6AddressCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "Ipv6Addresses", + "Terraform": null, + "Required": false + }, + { + "ROS": "Ipv6PrefixCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "Ipv6Prefixes", + "Terraform": null, + "Required": false + }, + { + "ROS": "NetworkInterfaceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::NetworkInterface" + } + ] + } + ], + "Attributes": [ + { + "ROS": "Ipv6Addresses", + "Terraform": null + }, + { + "ROS": "Ipv6AddressIds", + "Terraform": null, + "Primary": true + }, + { + "ROS": "NetworkInterfaceId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::NetworkInterface" + } + ] + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::AssignPrivateIpAddresses", + "Terraform": null + }, + "ProductCode": "ecs", + "Name": { + "zh": "内网IP地址", + "en": "Private IP Addresses" + }, + "Properties": [ + { + "ROS": "Ipv4PrefixCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "Ipv4Prefixes", + "Terraform": null, + "Required": false + }, + { + "ROS": "NetworkInterfaceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::NetworkInterface" + } + ] + }, + { + "ROS": "PrivateIpAddresses", + "Terraform": null, + "Required": false + }, + { + "ROS": "SecondaryPrivateIpAddressCount", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "NetworkInterfaceId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::NetworkInterface" + } + ] + }, + { + "ROS": "PrivateIpAddresses", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::AutoProvisioningGroup", + "Terraform": "alicloud_auto_provisioning_group" + }, + "ProductCode": "ecs", + "Name": { + "zh": "弹性供应组", + "en": "Auto Provisioning Group" + }, + "Properties": [ + { + "ROS": "AutoProvisioningGroupName", + "Terraform": "auto_provisioning_group_name", + "Required": false + }, + { + "ROS": "AutoProvisioningGroupType", + "Terraform": "auto_provisioning_group_type", + "Required": false + }, + { + "ROS": "CheckExecutionStatus", + "Terraform": null, + "Required": false + }, + { + "ROS": "DataDiskConfig", + "Terraform": null, + "Required": false, + "Type": "list", + "Properties": [ + { + "ROS": "DiskCategory", + "Terraform": null, + "Required": true + } + ] + }, + { + "ROS": "DefaultTargetCapacityType", + "Terraform": "default_target_capacity_type", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "ExcessCapacityTerminationPolicy", + "Terraform": "excess_capacity_termination_policy", + "Required": false + }, + { + "ROS": "LaunchConfiguration", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "AutoReleaseTime", + "Terraform": null, + "Required": false + }, + { + "ROS": "CreditSpecification", + "Terraform": null, + "Required": false + }, + { + "ROS": "DataDisk", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "BurstingEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "Category", + "Terraform": null, + "Required": false + }, + { + "ROS": "DeleteWithInstance", + "Terraform": null, + "Required": false + }, + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "Device", + "Terraform": null, + "Required": false + }, + { + "ROS": "DiskName", + "Terraform": null, + "Required": false + }, + { + "ROS": "Encrypted", + "Terraform": null, + "Required": false + }, + { + "ROS": "InternetChargeType", + "Terraform": null, + "Required": false + }, + { + "ROS": "KmsKeyId", + "Terraform": null, + "Required": false + }, + { + "ROS": "PerformanceLevel", + "Terraform": null, + "Required": false + }, + { + "ROS": "ProvisionedIops", + "Terraform": null, + "Required": false + }, + { + "ROS": "Size", + "Terraform": null, + "Required": false + }, + { + "ROS": "SnapshotId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Snapshot" + } + ] + } + ], + "Type": "list" + }, + { + "ROS": "DeploymentSetId", + "Terraform": null, + "Required": false + }, + { + "ROS": "HostName", + "Terraform": null, + "Required": false + }, + { + "ROS": "HostNames", + "Terraform": null, + "Required": false, + "Type": "list", + "Properties": {} + }, + { + "ROS": "ImageFamily", + "Terraform": null, + "Required": false + }, + { + "ROS": "ImageId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::CustomImage" + } + ] + }, + { + "ROS": "InstanceDescription", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceName", + "Terraform": null, + "Required": false + }, + { + "ROS": "InternetChargeType", + "Terraform": null, + "Required": false + }, + { + "ROS": "InternetMaxBandwidthOut", + "Terraform": null, + "Required": false + }, + { + "ROS": "IoOptimized", + "Terraform": null, + "Required": false + }, + { + "ROS": "KeyPairName", + "Terraform": null, + "Required": false + }, + { + "ROS": "PasswordInherit", + "Terraform": null, + "Required": false + }, + { + "ROS": "RamRoleName", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "SecurityEnhancementStrategy", + "Terraform": null, + "Required": false + }, + { + "ROS": "SecurityGroupId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "SecurityGroupIds", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ], + "Type": "list", + "Properties": {} + }, + { + "ROS": "SystemDiskBurstingEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskCategory", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskDescription", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskEncrypted", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskKMSKeyId", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskName", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskPerformanceLevel", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskProvisionedIops", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskSize", + "Terraform": null, + "Required": false + }, + { + "ROS": "Tag", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "UserData", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "LaunchTemplateConfig", + "Terraform": "launch_template_config", + "Required": false, + "Properties": [ + { + "ROS": "InstanceType", + "Terraform": "instance_type", + "Required": false + }, + { + "ROS": "MaxPrice", + "Terraform": "max_price", + "Required": false + }, + { + "ROS": "Priority", + "Terraform": "priority", + "Required": false + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "WeightedCapacity", + "Terraform": "weighted_capacity", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "LaunchTemplateId", + "Terraform": "launch_template_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::LaunchTemplate" + } + ] + }, + { + "ROS": "LaunchTemplateVersion", + "Terraform": "launch_template_version", + "Required": false + }, + { + "ROS": "MaxSpotPrice", + "Terraform": "max_spot_price", + "Required": false + }, + { + "ROS": "MinTargetCapacity", + "Terraform": null, + "Required": false + }, + { + "ROS": "PayAsYouGoAllocationStrategy", + "Terraform": "pay_as_you_go_allocation_strategy", + "Required": false + }, + { + "ROS": "PayAsYouGoTargetCapacity", + "Terraform": "pay_as_you_go_target_capacity", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourcePoolOptions", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "PrivatePoolIds", + "Terraform": null, + "Required": false, + "Type": "list", + "Properties": {} + }, + { + "ROS": "Strategy", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "SpotAllocationStrategy", + "Terraform": "spot_allocation_strategy", + "Required": false + }, + { + "ROS": "SpotInstanceInterruptionBehavior", + "Terraform": "spot_instance_interruption_behavior", + "Required": false + }, + { + "ROS": "SpotInstancePoolsToUseCount", + "Terraform": "spot_instance_pools_to_use_count", + "Required": false + }, + { + "ROS": "SpotTargetCapacity", + "Terraform": "spot_target_capacity", + "Required": false + }, + { + "ROS": "SystemDiskConfig", + "Terraform": null, + "Required": false, + "Type": "list", + "Properties": [ + { + "ROS": "DiskCategory", + "Terraform": null, + "Required": true + } + ] + }, + { + "ROS": "TerminateInstances", + "Terraform": "terminate_instances", + "Required": false + }, + { + "ROS": "TerminateInstancesWithExpiration", + "Terraform": "terminate_instances_with_expiration", + "Required": false + }, + { + "ROS": "TotalTargetCapacity", + "Terraform": "total_target_capacity", + "Required": true + }, + { + "ROS": "ValidFrom", + "Terraform": "valid_from", + "Required": false + }, + { + "ROS": "ValidUntil", + "Terraform": "valid_until", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "AutoProvisioningGroupName", + "Terraform": null + }, + { + "ROS": "AutoProvisioningGroupId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::AutoSnapshotPolicy", + "Terraform": "alicloud_ecs_auto_snapshot_policy" + }, + "ProductCode": "ecs", + "Name": { + "zh": "自动快照策略", + "en": "Automatic Snapshot Policy" + }, + "Properties": [ + { + "ROS": "CopiedSnapshotsRetentionDays", + "Terraform": "copied_snapshots_retention_days", + "Required": false + }, + { + "ROS": "CopyEncryptionConfiguration", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Encrypted", + "Terraform": null, + "Required": false + }, + { + "ROS": "KMSKeyId", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "DiskIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Disk" + } + ], + "Type": "list" + }, + { + "ROS": "EnableCrossRegionCopy", + "Terraform": "enable_cross_region_copy", + "Required": false + }, + { + "ROS": "AutoSnapshotPolicyName", + "Terraform": "name", + "Required": false + }, + { + "ROS": "RepeatWeekdays", + "Terraform": "repeat_weekdays", + "Required": true + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "RetentionDays", + "Terraform": "retention_days", + "Required": true + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "TargetCopyRegions", + "Terraform": "target_copy_regions", + "Required": false + }, + { + "ROS": "TimePoints", + "Terraform": "time_points", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": "AutoSnapshotPolicyId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::CapacityReservation", + "Terraform": "alicloud_ecs_capacity_reservation" + }, + "ProductCode": "ecs", + "Name": { + "zh": "ECS容量预定", + "en": "ECS Capacity Reservation" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "capacity_reservation_name", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": "EndTime", + "Terraform": "end_time", + "Required": false + }, + { + "ROS": "EndTimeType", + "Terraform": "end_time_type", + "Required": false + }, + { + "ROS": "InstanceAmount", + "Terraform": "instance_amount", + "Required": true + }, + { + "ROS": "InstanceType", + "Terraform": "instance_type", + "Required": true + }, + { + "ROS": null, + "Terraform": "match_criteria", + "Required": false + }, + { + "ROS": null, + "Terraform": "platform", + "Required": false + }, + { + "ROS": "PrivatePoolOptions", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "MatchCriteria", + "Terraform": null, + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "ZoneId", + "Terraform": null, + "Required": true + }, + { + "ROS": null, + "Terraform": "zone_ids", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "PrivatePoolOptionsId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "payment_type" + }, + { + "ROS": null, + "Terraform": "start_time" + }, + { + "ROS": null, + "Terraform": "start_time_type" + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": null, + "Terraform": "time_slot" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::Command", + "Terraform": "alicloud_ecs_command" + }, + "ProductCode": "ecs", + "Name": { + "zh": "云助手命令", + "en": "Cloud Assistant Command" + }, + "Properties": [ + { + "ROS": "CommandContent", + "Terraform": "command_content", + "Required": false + }, + { + "ROS": "ContentEncoding", + "Terraform": null, + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "EnableParameter", + "Terraform": "enable_parameter", + "Required": false + }, + { + "ROS": "Name", + "Terraform": "name", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "Timeout", + "Terraform": "timeout", + "Required": false + }, + { + "ROS": "Type", + "Terraform": "type", + "Required": true + }, + { + "ROS": "WorkingDir", + "Terraform": "working_dir", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "CommandId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::CopyImage", + "Terraform": "alicloud_image_copy" + }, + "ProductCode": "ecs", + "Name": { + "zh": "ECS复制镜像", + "en": "Copy ECS Image" + }, + "Properties": [ + { + "ROS": "AllowCopyInSameRegion", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": "DestinationDescription", + "Terraform": null, + "Required": false + }, + { + "ROS": "DestinationRegionId", + "Terraform": null, + "Required": true + }, + { + "ROS": "Encrypted", + "Terraform": "encrypted", + "Required": false + }, + { + "ROS": null, + "Terraform": "force", + "Required": false + }, + { + "ROS": "DestinationImageName", + "Terraform": "image_name", + "Required": false + }, + { + "ROS": "KMSKeyId", + "Terraform": "kms_key_id", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "ImageId", + "Terraform": "source_image_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::CustomImage" + } + ] + }, + { + "ROS": "SourceRegionId", + "Terraform": "source_region_id", + "Required": false + }, + { + "ROS": "Tag", + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "DestinationRegionId", + "Terraform": null + }, + { + "ROS": "ImageId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::CustomImage" + } + ] + }, + { + "ROS": "SourceRegionId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::CustomImage", + "Terraform": "alicloud_image" + }, + "ProductCode": "ecs", + "Name": { + "zh": "ECS自定义镜像", + "en": "ECS Custom Image" + }, + "Properties": [ + { + "ROS": "Architecture", + "Terraform": "architecture", + "Required": false + }, + { + "ROS": "BootMode", + "Terraform": "boot_mode", + "Required": false + }, + { + "ROS": null, + "Terraform": "delete_auto_snapshot", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "DetectionStrategy", + "Terraform": "detection_strategy", + "Required": false + }, + { + "ROS": "DiskDeviceMapping", + "Terraform": "disk_device_mapping", + "Required": false, + "Properties": [ + { + "ROS": "Device", + "Terraform": "device", + "Required": false + }, + { + "ROS": "DiskType", + "Terraform": "disk_type", + "Required": false + }, + { + "ROS": "Size", + "Terraform": "size", + "Required": false + }, + { + "ROS": "SnapshotId", + "Terraform": "snapshot_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Snapshot" + } + ] + } + ], + "Type": "list" + }, + { + "ROS": null, + "Terraform": "features", + "Required": false + }, + { + "ROS": null, + "Terraform": "force", + "Required": false + }, + { + "ROS": "ImageFamily", + "Terraform": "image_family", + "Required": false + }, + { + "ROS": "ImageName", + "Terraform": "image_name", + "Required": false + }, + { + "ROS": "ImageVersion", + "Terraform": "image_version", + "Required": false + }, + { + "ROS": "InstanceId", + "Terraform": "instance_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Instance" + }, + { + "ResourceType": "ROS/ALIYUN::ECS::InstanceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "license_type", + "Required": false + }, + { + "ROS": "Platform", + "Terraform": "platform", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "SnapshotId", + "Terraform": "snapshot_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Snapshot" + } + ] + }, + { + "ROS": "SourceRegionId", + "Terraform": null, + "Required": false + }, + { + "ROS": "Tag", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": false + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "disk_device_mapping" + }, + { + "ROS": "ImageId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "SourceRegionId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::DedicatedHost", + "Terraform": "alicloud_ecs_dedicated_host" + }, + "ProductCode": "ecs", + "Name": { + "zh": "专有宿主机", + "en": "Dedicated Host" + }, + "Properties": [ + { + "ROS": "ActionOnMaintenance", + "Terraform": "action_on_maintenance", + "Required": false + }, + { + "ROS": "AutoPlacement", + "Terraform": "auto_placement", + "Required": false + }, + { + "ROS": "AutoReleaseTime", + "Terraform": "auto_release_time", + "Required": false + }, + { + "ROS": "AutoRenew", + "Terraform": "auto_renew", + "Required": false + }, + { + "ROS": "AutoRenewPeriod", + "Terraform": "auto_renew_period", + "Required": false + }, + { + "ROS": "ChargeType", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "cpu_over_commit_ratio", + "Required": false + }, + { + "ROS": null, + "Terraform": "dedicated_host_cluster_id", + "Required": false + }, + { + "ROS": "DedicatedHostName", + "Terraform": "dedicated_host_name", + "Required": false + }, + { + "ROS": "DedicatedHostType", + "Terraform": "dedicated_host_type", + "Required": true + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "detail_fee", + "Required": false + }, + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": null, + "Terraform": "expired_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "min_quantity", + "Required": false + }, + { + "ROS": null, + "Terraform": "network_attributes", + "Required": false + }, + { + "ROS": "NetworkAttributesSlbUdpTimeout", + "Terraform": null, + "Required": false + }, + { + "ROS": "NetworkAttributesUdpTimeout", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": "Period", + "Terraform": null, + "Required": false + }, + { + "ROS": "Quantity", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "PeriodUnit", + "Terraform": "sale_cycle", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "ZoneId", + "Terraform": "zone_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": "DedicatedHostIds", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "OrderId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::DeploymentSet", + "Terraform": "alicloud_ecs_deployment_set" + }, + "ProductCode": "ecs", + "Name": { + "zh": "部署集", + "en": "Deployment Set" + }, + "Properties": [ + { + "ROS": "DeploymentSetName", + "Terraform": "deployment_set_name", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "domain", + "Required": false + }, + { + "ROS": null, + "Terraform": "granularity", + "Required": false + }, + { + "ROS": "GroupCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "OnUnableToRedeployFailedInstance", + "Terraform": "on_unable_to_redeploy_failed_instance", + "Required": false + }, + { + "ROS": "Strategy", + "Terraform": "strategy", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "DeploymentSetId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::Disk", + "Terraform": "alicloud_ecs_disk" + }, + "ProductCode": "ecs", + "Name": { + "zh": "云盘", + "en": "Cloud Disk" + }, + "Properties": [ + { + "ROS": "AutoSnapshotPolicyId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::AutoSnapshotPolicy" + } + ] + }, + { + "ROS": "BurstingEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "category", + "Required": false + }, + { + "ROS": "DeleteAutoSnapshot", + "Terraform": "delete_auto_snapshot", + "Required": false + }, + { + "ROS": null, + "Terraform": "delete_with_instance", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "DiskCategory", + "Terraform": null, + "Required": false + }, + { + "ROS": "DiskName", + "Terraform": "disk_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": null, + "Terraform": "enable_auto_snapshot", + "Required": false + }, + { + "ROS": "Encrypted", + "Terraform": "encrypted", + "Required": false + }, + { + "ROS": "InstanceId", + "Terraform": "instance_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Instance" + }, + { + "ResourceType": "ROS/ALIYUN::ECS::InstanceGroup" + } + ] + }, + { + "ROS": "KMSKeyId", + "Terraform": "kms_key_id", + "Required": false + }, + { + "ROS": "MultiAttach", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": "PerformanceLevel", + "Terraform": "performance_level", + "Required": false + }, + { + "ROS": "ProvisionedIops", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "Size", + "Terraform": "size", + "Required": false + }, + { + "ROS": "SnapshotId", + "Terraform": "snapshot_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Snapshot" + } + ] + }, + { + "ROS": "StorageSetId", + "Terraform": "storage_set_id", + "Required": false + }, + { + "ROS": "StorageSetPartitionNumber", + "Terraform": "storage_set_partition_number", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": null, + "Terraform": "type", + "Required": false + }, + { + "ROS": "ZoneId", + "Terraform": "zone_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "DiskId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "Status", + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::DiskAttachment", + "Terraform": "alicloud_ecs_disk_attachment" + }, + "MainResourceType": { + "ResourceType": "ROS/ALIYUN::ECS::Disk", + "RefProperty": "ROS/DiskId" + }, + "ProductCode": "ecs", + "Name": { + "zh": "绑定云盘", + "en": "Attach Cloud Disk" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "bootable", + "Required": false + }, + { + "ROS": "DeleteAutoSnapshot", + "Terraform": null, + "Required": false + }, + { + "ROS": "DeleteWithInstance", + "Terraform": "delete_with_instance", + "Required": false + }, + { + "ROS": "Device", + "Terraform": null, + "Required": false + }, + { + "ROS": "DiskId", + "Terraform": "disk_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Disk" + } + ] + }, + { + "ROS": "InstanceId", + "Terraform": "instance_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Instance" + }, + { + "ResourceType": "ROS/ALIYUN::ECS::InstanceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "key_pair_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "password", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Device", + "Terraform": "device" + }, + { + "ROS": "DiskId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Disk" + } + ] + }, + { + "ROS": "DiskId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "Status", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::ElasticityAssurance", + "Terraform": "alicloud_ecs_elasticity_assurance" + }, + "ProductCode": "ecs", + "Name": { + "zh": "ECS弹性保障", + "en": "ECS Elasticity Assurance" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "assurance_times", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "InstanceAmount", + "Terraform": "instance_amount", + "Required": true + }, + { + "ROS": null, + "Terraform": "instance_type", + "Required": false + }, + { + "ROS": "InstanceTypes", + "Terraform": null, + "Required": true, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "Period", + "Terraform": "period", + "Required": false + }, + { + "ROS": "PeriodUnit", + "Terraform": "period_unit", + "Required": false + }, + { + "ROS": "PrivatePoolOptions", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "MatchCriteria", + "Terraform": null, + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": null, + "Terraform": "private_pool_options_match_criteria", + "Required": false + }, + { + "ROS": null, + "Terraform": "private_pool_options_name", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "StartTime", + "Terraform": "start_time", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "ZoneId", + "Terraform": null, + "Required": true + }, + { + "ROS": null, + "Terraform": "zone_ids", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "elasticity_assurance_id" + }, + { + "ROS": null, + "Terraform": "end_time" + }, + { + "ROS": "PrivatePoolOptionsId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "instance_charge_type" + }, + { + "ROS": null, + "Terraform": "start_time_type" + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": null, + "Terraform": "used_assurance_times" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::ForwardEntry", + "Terraform": "alicloud_forward_entry" + }, + "ProductCode": "ecs", + "Name": { + "zh": "DNAT表", + "en": "DNAT Table" + }, + "Properties": [ + { + "ROS": "ExternalIp", + "Terraform": "external_ip", + "Required": true + }, + { + "ROS": "ExternalPort", + "Terraform": "external_port", + "Required": true + }, + { + "ROS": "ForwardEntryName", + "Terraform": "forward_entry_name", + "Required": false + }, + { + "ROS": "ForwardTableId", + "Terraform": "forward_table_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::NatGateway" + } + ] + }, + { + "ROS": "InternalIp", + "Terraform": "internal_ip", + "Required": true + }, + { + "ROS": "InternalPort", + "Terraform": "internal_port", + "Required": true + }, + { + "ROS": "IpProtocol", + "Terraform": "ip_protocol", + "Required": true + }, + { + "ROS": "PortBreak", + "Terraform": "port_break", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "ForwardEntryId", + "Terraform": "forward_entry_id" + }, + { + "ROS": "ForwardEntryId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::HpcCluster", + "Terraform": "alicloud_ecs_hpc_cluster" + }, + "ProductCode": "ecs", + "Name": { + "zh": "HPC集群", + "en": "HPC Cluster" + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "Name", + "Terraform": "name", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "HpcClusterId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "Name", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::ImageComponent", + "Terraform": "alicloud_ecs_image_component" + }, + "ProductCode": "ecs", + "Name": { + "zh": "ECS镜像组件", + "en": "ECS Image Component" + }, + "Properties": [ + { + "ROS": "ComponentType", + "Terraform": "component_type", + "Required": false + }, + { + "ROS": "Content", + "Terraform": "content", + "Required": true + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "image_component_name", + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "SystemType", + "Terraform": "system_type", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "ImageComponentId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::ImagePipeline", + "Terraform": "alicloud_ecs_image_pipeline" + }, + "ProductCode": "ecs", + "Name": { + "zh": "ECS镜像模板", + "en": "ECS Image Template" + }, + "Properties": [ + { + "ROS": "AddAccount", + "Terraform": "add_account", + "Required": false + }, + { + "ROS": "BaseImage", + "Terraform": "base_image", + "Required": true + }, + { + "ROS": "BaseImageType", + "Terraform": "base_image_type", + "Required": true + }, + { + "ROS": "BuildContent", + "Terraform": "build_content", + "Required": false + }, + { + "ROS": "DeleteInstanceOnFailure", + "Terraform": "delete_instance_on_failure", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "ExecutePipeline", + "Terraform": null, + "Required": false + }, + { + "ROS": "ImageName", + "Terraform": "image_name", + "Required": false + }, + { + "ROS": "InstanceType", + "Terraform": "instance_type", + "Required": false + }, + { + "ROS": "InternetMaxBandwidthOut", + "Terraform": "internet_max_bandwidth_out", + "Required": false + }, + { + "ROS": "Name", + "Terraform": "name", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "SystemDiskSize", + "Terraform": "system_disk_size", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "ToRegionId", + "Terraform": "to_region_id", + "Required": false + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Attributes": [ + { + "ROS": "ImagePipelineId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::ImageSharePermission", + "Terraform": "alicloud_image_share_permission" + }, + "ProductCode": "ecs", + "Name": { + "zh": "ECS镜像共享权限", + "en": "ECS Image Share Permissions" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "account_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::Account" + } + ] + }, + { + "ROS": "Accounts", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "ImageId", + "Terraform": "image_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::CustomImage" + } + ] + }, + { + "ROS": "IsPublic", + "Terraform": null, + "Required": false + }, + { + "ROS": "KeepPermission", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "ImageId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::CustomImage" + } + ] + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::Instance", + "Terraform": "alicloud_instance" + }, + "ProductCode": "ecs", + "Name": { + "zh": "云服务器实例", + "en": "ECS Instance" + }, + "Properties": [ + { + "ROS": "Affinity", + "Terraform": null, + "Required": false + }, + { + "ROS": "AllocatePublicIP", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "auto_release_time", + "Required": false + }, + { + "ROS": "AutoRenew", + "Terraform": null, + "Required": false + }, + { + "ROS": "AutoRenewPeriod", + "Terraform": "auto_renew_period", + "Required": false + }, + { + "ROS": "ZoneId", + "Terraform": "availability_zone", + "Required": false, + "RelatedTo": [ + { + "DataSourceType": "ROS/DATASOURCE::ECS::Zones" + } + ] + }, + { + "ROS": "CreditSpecification", + "Terraform": "credit_specification", + "Required": false + }, + { + "ROS": "DiskMappings", + "Terraform": "data_disks", + "Required": false, + "Properties": [ + { + "ROS": null, + "Terraform": "auto_snapshot_policy_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::AutoSnapshotPolicy" + } + ] + }, + { + "ROS": "Category", + "Terraform": "category", + "Required": false + }, + { + "ROS": null, + "Terraform": "delete_with_instance", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "Device", + "Terraform": "device", + "Required": false + }, + { + "ROS": null, + "Terraform": "encrypted", + "Required": false + }, + { + "ROS": null, + "Terraform": "kms_key_id", + "Required": false + }, + { + "ROS": "DiskName", + "Terraform": "name", + "Required": false + }, + { + "ROS": "PerformanceLevel", + "Terraform": "performance_level", + "Required": false + }, + { + "ROS": "Size", + "Terraform": "size", + "Required": true + }, + { + "ROS": "SnapshotId", + "Terraform": "snapshot_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Snapshot" + } + ] + } + ], + "Type": "list" + }, + { + "ROS": "DedicatedHostId", + "Terraform": "dedicated_host_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::DedicatedHost" + } + ] + }, + { + "ROS": "DeletionProtection", + "Terraform": "deletion_protection", + "Required": false + }, + { + "ROS": "DeploymentSetGroupNo", + "Terraform": null, + "Required": false + }, + { + "ROS": "DeploymentSetId", + "Terraform": "deployment_set_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::DeploymentSet" + } + ] + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": null, + "Terraform": "enable_jumbo_frame", + "Required": false + }, + { + "ROS": null, + "Terraform": "force_delete", + "Required": false + }, + { + "ROS": "HostName", + "Terraform": "host_name", + "Required": false + }, + { + "ROS": "HpcClusterId", + "Terraform": "hpc_cluster_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::HpcCluster" + } + ] + }, + { + "ROS": "HttpEndpoint", + "Terraform": "http_endpoint", + "Required": false + }, + { + "ROS": null, + "Terraform": "http_put_response_hop_limit", + "Required": false + }, + { + "ROS": "HttpTokens", + "Terraform": "http_tokens", + "Required": false + }, + { + "ROS": "ImageFamily", + "Terraform": null, + "Required": false + }, + { + "ROS": "ImageId", + "Terraform": "image_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::CustomImage" + } + ] + }, + { + "ROS": null, + "Terraform": "include_data_disks", + "Required": false + }, + { + "ROS": "InstanceChargeType", + "Terraform": "instance_charge_type", + "Required": false + }, + { + "ROS": "InstanceName", + "Terraform": "instance_name", + "Required": false + }, + { + "ROS": "InstanceType", + "Terraform": "instance_type", + "Required": true + }, + { + "ROS": "InternetChargeType", + "Terraform": "internet_charge_type", + "Required": false + }, + { + "ROS": "InternetMaxBandwidthOut", + "Terraform": "internet_max_bandwidth_out", + "Required": false + }, + { + "ROS": "IoOptimized", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "ipv6_address_count", + "Required": false + }, + { + "ROS": null, + "Terraform": "ipv6_addresses", + "Required": false + }, + { + "ROS": null, + "Terraform": "is_outdated", + "Required": false + }, + { + "ROS": "KeyPairName", + "Terraform": "key_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "kms_encrypted_password", + "Required": false + }, + { + "ROS": null, + "Terraform": "kms_encryption_context", + "Required": false + }, + { + "ROS": null, + "Terraform": "launch_template_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::LaunchTemplate" + } + ] + }, + { + "ROS": null, + "Terraform": "launch_template_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "launch_template_version", + "Required": false + }, + { + "ROS": null, + "Terraform": "maintenance_action", + "Required": false + }, + { + "ROS": null, + "Terraform": "maintenance_notify", + "Required": false + }, + { + "ROS": null, + "Terraform": "maintenance_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "network_card_index", + "Required": false + }, + { + "ROS": null, + "Terraform": "network_interfaces", + "Required": false + }, + { + "ROS": null, + "Terraform": "network_interface_traffic_mode", + "Required": false + }, + { + "ROS": null, + "Terraform": "operator_type", + "Required": false + }, + { + "ROS": "Password", + "Terraform": "password", + "Required": false + }, + { + "ROS": "PasswordInherit", + "Terraform": "password_inherit", + "Required": false + }, + { + "ROS": "Period", + "Terraform": "period", + "Required": false + }, + { + "ROS": "PeriodUnit", + "Terraform": "period_unit", + "Required": false + }, + { + "ROS": "PrivateIpAddress", + "Terraform": "private_ip", + "Required": false + }, + { + "ROS": "PrivatePoolOptions", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Id", + "Terraform": null, + "Required": false + }, + { + "ROS": "MatchCriteria", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": null, + "Terraform": "queue_pair_number", + "Required": false + }, + { + "ROS": null, + "Terraform": "renewal_status", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "RamRoleName", + "Terraform": "role_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "secondary_private_ip_address_count", + "Required": false + }, + { + "ROS": null, + "Terraform": "secondary_private_ips", + "Required": false + }, + { + "ROS": "SecurityEnhancementStrategy", + "Terraform": "security_enhancement_strategy", + "Required": false + }, + { + "ROS": "SecurityGroupIds", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ], + "Properties": {}, + "Type": "list" + }, + { + "ROS": "SecurityGroupId", + "Terraform": "security_groups", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "SpotDuration", + "Terraform": "spot_duration", + "Required": false + }, + { + "ROS": "SpotInterruptionBehavior", + "Terraform": null, + "Required": false + }, + { + "ROS": "SpotPriceLimit", + "Terraform": "spot_price_limit", + "Required": false + }, + { + "ROS": "SpotStrategy", + "Terraform": "spot_strategy", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": null, + "Terraform": "stopped_mode", + "Required": false + }, + { + "ROS": "StorageSetId", + "Terraform": null, + "Required": false + }, + { + "ROS": "StorageSetPartitionNumber", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "subnet_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "system_disk_auto_snapshot_policy_id", + "Required": false + }, + { + "ROS": "SystemDiskCategory", + "Terraform": "system_disk_category", + "Required": false + }, + { + "ROS": "SystemDiskDescription", + "Terraform": "system_disk_description", + "Required": false + }, + { + "ROS": "SystemDiskDiskName", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "system_disk_encrypt_algorithm", + "Required": false + }, + { + "ROS": null, + "Terraform": "system_disk_encrypted", + "Required": false + }, + { + "ROS": null, + "Terraform": "system_disk_kms_key_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "system_disk_name", + "Required": false + }, + { + "ROS": "SystemDiskPerformanceLevel", + "Terraform": "system_disk_performance_level", + "Required": false + }, + { + "ROS": "SystemDiskSize", + "Terraform": "system_disk_size", + "Required": false + }, + { + "ROS": null, + "Terraform": "system_disk_storage_cluster_id", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "Tenancy", + "Terraform": null, + "Required": false + }, + { + "ROS": "UseAdditionalService", + "Terraform": null, + "Required": false + }, + { + "ROS": "UserData", + "Terraform": "user_data", + "Required": false + }, + { + "ROS": null, + "Terraform": "volume_tags", + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "ZoneIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "cpu" + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "deployment_set_group_no" + }, + { + "ROS": null, + "Terraform": "expired_time" + }, + { + "ROS": "HostName", + "Terraform": null + }, + { + "ROS": "InstanceId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "InnerIp", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "memory" + }, + { + "ROS": null, + "Terraform": "network_interface_id", + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::NetworkInterface" + } + ] + }, + { + "ROS": null, + "Terraform": "os_name" + }, + { + "ROS": null, + "Terraform": "os_type" + }, + { + "ROS": null, + "Terraform": "primary_ip_address" + }, + { + "ROS": "PrimaryNetworkInterfaceId", + "Terraform": null + }, + { + "ROS": "PrivateIp", + "Terraform": null + }, + { + "ROS": "PublicIp", + "Terraform": "public_ip" + }, + { + "ROS": "SecurityGroupIds", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "start_time" + }, + { + "ROS": null, + "Terraform": "system_disk_id" + }, + { + "ROS": "ZoneId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::InstanceClone", + "Terraform": null + }, + "ProductCode": "ecs", + "Name": { + "zh": "克隆云服务器实例", + "en": "Clone ECS Instance" + }, + "Properties": [ + { + "ROS": "BackendServerWeight", + "Terraform": null, + "Required": false + }, + { + "ROS": "DeletionProtection", + "Terraform": null, + "Required": false + }, + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "DiskMappings", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Category", + "Terraform": null, + "Required": false + }, + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "Device", + "Terraform": null, + "Required": false + }, + { + "ROS": "DiskName", + "Terraform": null, + "Required": false + }, + { + "ROS": "PerformanceLevel", + "Terraform": null, + "Required": false + }, + { + "ROS": "Size", + "Terraform": null, + "Required": true + }, + { + "ROS": "SnapshotId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Snapshot" + } + ] + } + ], + "Type": "list" + }, + { + "ROS": "ImageId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::CustomImage" + } + ] + }, + { + "ROS": "InstanceChargeType", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceName", + "Terraform": null, + "Required": false + }, + { + "ROS": "InternetMaxBandwidthIn", + "Terraform": null, + "Required": false + }, + { + "ROS": "KeyPairName", + "Terraform": null, + "Required": false + }, + { + "ROS": "LoadBalancerIdToAttach", + "Terraform": null, + "Required": false + }, + { + "ROS": "Password", + "Terraform": null, + "Required": false + }, + { + "ROS": "Period", + "Terraform": null, + "Required": false + }, + { + "ROS": "RamRoleName", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "SecurityGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "SourceInstanceId", + "Terraform": null, + "Required": true + }, + { + "ROS": "SpotPriceLimit", + "Terraform": null, + "Required": false + }, + { + "ROS": "SpotStrategy", + "Terraform": null, + "Required": false + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "ZoneId", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "HostName", + "Terraform": null + }, + { + "ROS": "InnerIp", + "Terraform": null + }, + { + "ROS": "InstanceId", + "Terraform": null + }, + { + "ROS": "PrimaryNetworkInterfaceId", + "Terraform": null + }, + { + "ROS": "PrivateIp", + "Terraform": null + }, + { + "ROS": "PublicIp", + "Terraform": null + }, + { + "ROS": "SecurityGroupIds", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "ZoneId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::InstanceGroup", + "Terraform": "alicloud_ecs_instance_set" + }, + "ProductCode": "ecs", + "Name": { + "zh": "云服务器实例组", + "en": "ECS Instance Group" + }, + "Properties": [ + { + "ROS": "Affinity", + "Terraform": null, + "Required": false + }, + { + "ROS": "AllocatePublicIP", + "Terraform": null, + "Required": false + }, + { + "ROS": "MaxAmount", + "Terraform": "amount", + "Required": true + }, + { + "ROS": "AutoReleaseTime", + "Terraform": "auto_release_time", + "Required": false + }, + { + "ROS": "AutoRenew", + "Terraform": "auto_renew", + "Required": false + }, + { + "ROS": "AutoRenewPeriod", + "Terraform": "auto_renew_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "boot_check_os_with_assistant", + "Required": false + }, + { + "ROS": "CpuOptions", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Core", + "Terraform": null, + "Required": false + }, + { + "ROS": "ThreadsPerCore", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "CreditSpecification", + "Terraform": null, + "Required": false + }, + { + "ROS": "DiskMappings", + "Terraform": "data_disks", + "Required": false, + "Properties": [ + { + "ROS": "AutoSnapshotPolicyId", + "Terraform": "auto_snapshot_policy_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::AutoSnapshotPolicy" + } + ] + }, + { + "ROS": "Category", + "Terraform": "disk_category", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "disk_description", + "Required": false + }, + { + "ROS": "DiskName", + "Terraform": "disk_name", + "Required": false + }, + { + "ROS": "Size", + "Terraform": "disk_size", + "Required": true + }, + { + "ROS": "Encrypted", + "Terraform": "encrypted", + "Required": false + }, + { + "ROS": "KMSKeyId", + "Terraform": "kms_key_id", + "Required": false + }, + { + "ROS": "PerformanceLevel", + "Terraform": "performance_level", + "Required": false + }, + { + "ROS": "SnapshotId", + "Terraform": "snapshot_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Snapshot" + } + ] + } + ], + "Type": "list" + }, + { + "ROS": "DedicatedHostId", + "Terraform": "dedicated_host_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::DedicatedHost" + } + ] + }, + { + "ROS": "DeletionForce", + "Terraform": null, + "Required": false + }, + { + "ROS": "DeletionProtection", + "Terraform": "deletion_protection", + "Required": false + }, + { + "ROS": "DeploymentSetGroupNo", + "Terraform": null, + "Required": false + }, + { + "ROS": "DeploymentSetId", + "Terraform": "deployment_set_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::DeploymentSet" + } + ] + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "exclude_instance_filter", + "Required": false + }, + { + "ROS": "HostName", + "Terraform": "host_name", + "Required": false + }, + { + "ROS": "HostNames", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "HpcClusterId", + "Terraform": "hpc_cluster_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::HpcCluster" + } + ] + }, + { + "ROS": "HttpEndpoint", + "Terraform": null, + "Required": false + }, + { + "ROS": "HttpTokens", + "Terraform": null, + "Required": false + }, + { + "ROS": "ImageFamily", + "Terraform": null, + "Required": false + }, + { + "ROS": "ImageId", + "Terraform": "image_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::CustomImage" + } + ] + }, + { + "ROS": "ImageOptions", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "LoginAsNonRoot", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "InstanceChargeType", + "Terraform": "instance_charge_type", + "Required": false + }, + { + "ROS": "InstanceName", + "Terraform": "instance_name", + "Required": false + }, + { + "ROS": "InstanceType", + "Terraform": "instance_type", + "Required": true + }, + { + "ROS": "InternetChargeType", + "Terraform": "internet_charge_type", + "Required": false + }, + { + "ROS": "InternetMaxBandwidthOut", + "Terraform": "internet_max_bandwidth_out", + "Required": false + }, + { + "ROS": "IoOptimized", + "Terraform": null, + "Required": false + }, + { + "ROS": "Ipv6AddressCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "Ipv6Addresses", + "Terraform": null, + "Required": false + }, + { + "ROS": "KeyPairName", + "Terraform": "key_pair_name", + "Required": false + }, + { + "ROS": "LaunchTemplateId", + "Terraform": "launch_template_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::LaunchTemplate" + } + ] + }, + { + "ROS": "LaunchTemplateName", + "Terraform": "launch_template_name", + "Required": false + }, + { + "ROS": "LaunchTemplateVersion", + "Terraform": "launch_template_version", + "Required": false + }, + { + "ROS": "NetworkInterfaceQueueNumber", + "Terraform": null, + "Required": false + }, + { + "ROS": "EniMappings", + "Terraform": "network_interfaces", + "Required": false, + "Properties": [ + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "NetworkInterfaceName", + "Terraform": "network_interface_name", + "Required": false + }, + { + "ROS": "PrimaryIpAddress", + "Terraform": "primary_ip_address", + "Required": false + }, + { + "ROS": "SecurityGroupId", + "Terraform": "security_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Type": "list" + }, + { + "ROS": "NetworkOptions", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "EnableJumboFrame", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "NetworkType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Password", + "Terraform": "password", + "Required": false + }, + { + "ROS": "PasswordInherit", + "Terraform": "password_inherit", + "Required": false + }, + { + "ROS": "Period", + "Terraform": "period", + "Required": false + }, + { + "ROS": "PeriodUnit", + "Terraform": "period_unit", + "Required": false + }, + { + "ROS": "PrivateIpAddress", + "Terraform": null, + "Required": false + }, + { + "ROS": "PrivatePoolOptions", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Id", + "Terraform": null, + "Required": false + }, + { + "ROS": "MatchCriteria", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "RamRoleName", + "Terraform": "ram_role_name", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "SchedulerOptions", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "DedicatedHostClusterId", + "Terraform": null, + "Required": false + }, + { + "ROS": "ManagedPrivateSpaceId", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "SecurityEnhancementStrategy", + "Terraform": "security_enhancement_strategy", + "Required": false + }, + { + "ROS": "SecurityGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "SecurityGroupIds", + "Terraform": "security_group_ids", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "SecurityOptions", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "TrustedSystemMode", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "SpotDuration", + "Terraform": null, + "Required": false + }, + { + "ROS": "SpotInterruptionBehavior", + "Terraform": null, + "Required": false + }, + { + "ROS": "SpotPriceLimit", + "Terraform": "spot_price_limit", + "Required": false + }, + { + "ROS": "SpotStrategy", + "Terraform": "spot_strategy", + "Required": false + }, + { + "ROS": "StorageSetId", + "Terraform": null, + "Required": false + }, + { + "ROS": "StorageSetPartitionNumber", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskAutoSnapshotPolicyId", + "Terraform": "system_disk_auto_snapshot_policy_id", + "Required": false + }, + { + "ROS": "SystemDiskBurstingEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskCategory", + "Terraform": "system_disk_category", + "Required": false + }, + { + "ROS": "SystemDiskDescription", + "Terraform": "system_disk_description", + "Required": false + }, + { + "ROS": "SystemDiskEncryptAlgorithm", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskEncrypted", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskKMSKeyId", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskDiskName", + "Terraform": "system_disk_name", + "Required": false + }, + { + "ROS": "SystemDiskPerformanceLevel", + "Terraform": "system_disk_performance_level", + "Required": false + }, + { + "ROS": "SystemDiskProvisionedIops", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskSize", + "Terraform": "system_disk_size", + "Required": false + }, + { + "ROS": "SystemDiskStorageClusterId", + "Terraform": null, + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "Tenancy", + "Terraform": null, + "Required": false + }, + { + "ROS": "UniqueSuffix", + "Terraform": "unique_suffix", + "Required": false + }, + { + "ROS": "UpdatePolicy", + "Terraform": null, + "Required": false + }, + { + "ROS": "UseAdditionalService", + "Terraform": null, + "Required": false + }, + { + "ROS": "UserData", + "Terraform": null, + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "ZoneId", + "Terraform": "zone_id", + "Required": false, + "RelatedTo": [ + { + "DataSourceType": "ROS/DATASOURCE::ECS::Zones" + } + ] + }, + { + "ROS": "ZoneIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "HostNames", + "Terraform": null + }, + { + "ROS": "InstanceIds", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "InnerIps", + "Terraform": null + }, + { + "ROS": "InstanceIds", + "Terraform": "instance_ids" + }, + { + "ROS": "Ipv6Addresses", + "Terraform": null + }, + { + "ROS": "Ipv6AddressIds", + "Terraform": null + }, + { + "ROS": "OrderId", + "Terraform": null + }, + { + "ROS": "PrivateIps", + "Terraform": null + }, + { + "ROS": "PublicIps", + "Terraform": null + }, + { + "ROS": "RelatedOrderIds", + "Terraform": null + }, + { + "ROS": "ZoneIds", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::InstanceGroupClone", + "Terraform": null + }, + "ProductCode": "ecs", + "Name": { + "zh": "克隆云服务器实例组", + "en": "Clone ECS Instance Group" + }, + "Properties": [ + { + "ROS": "AutoReleaseTime", + "Terraform": null, + "Required": false + }, + { + "ROS": "AutoRenew", + "Terraform": null, + "Required": false + }, + { + "ROS": "AutoRenewPeriod", + "Terraform": null, + "Required": false + }, + { + "ROS": "BackendServerWeight", + "Terraform": null, + "Required": false + }, + { + "ROS": "CpuOptions", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Core", + "Terraform": null, + "Required": false + }, + { + "ROS": "ThreadsPerCore", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "DeletionProtection", + "Terraform": null, + "Required": false + }, + { + "ROS": "DeploymentSetId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::DeploymentSet" + } + ] + }, + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "DiskMappings", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "AutoSnapshotPolicyId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::AutoSnapshotPolicy" + } + ] + }, + { + "ROS": "BurstingEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "Category", + "Terraform": null, + "Required": false + }, + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "Device", + "Terraform": null, + "Required": false + }, + { + "ROS": "DiskName", + "Terraform": null, + "Required": false + }, + { + "ROS": "Encrypted", + "Terraform": null, + "Required": false + }, + { + "ROS": "KMSKeyId", + "Terraform": null, + "Required": false + }, + { + "ROS": "PerformanceLevel", + "Terraform": null, + "Required": false + }, + { + "ROS": "ProvisionedIops", + "Terraform": null, + "Required": false + }, + { + "ROS": "Size", + "Terraform": null, + "Required": true + }, + { + "ROS": "SnapshotId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Snapshot" + } + ] + }, + { + "ROS": "StorageClusterId", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "EniMappings", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "DeleteOnRelease", + "Terraform": null, + "Required": false + }, + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Ipv6AddressCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "Ipv6Addresses", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "NetworkCardIndex", + "Terraform": null, + "Required": false + }, + { + "ROS": "NetworkInterfaceId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::NetworkInterface" + } + ] + }, + { + "ROS": "NetworkInterfaceName", + "Terraform": null, + "Required": false + }, + { + "ROS": "NetworkInterfaceTrafficMode", + "Terraform": null, + "Required": false + }, + { + "ROS": "PrimaryIpAddress", + "Terraform": null, + "Required": false + }, + { + "ROS": "QueueNumber", + "Terraform": null, + "Required": false + }, + { + "ROS": "QueuePairNumber", + "Terraform": null, + "Required": false + }, + { + "ROS": "SecurityGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "SecurityGroupIds", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Type": "list" + }, + { + "ROS": "HostNames", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "HpcClusterId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::HpcCluster" + } + ] + }, + { + "ROS": "ImageId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::CustomImage" + } + ] + }, + { + "ROS": "ImageOptions", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "LoginAsNonRoot", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "InstanceName", + "Terraform": null, + "Required": false + }, + { + "ROS": "InternetMaxBandwidthIn", + "Terraform": null, + "Required": false + }, + { + "ROS": "InternetMaxBandwidthOut", + "Terraform": null, + "Required": false + }, + { + "ROS": "Ipv6AddressCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "Ipv6Addresses", + "Terraform": null, + "Required": false + }, + { + "ROS": "KeyPairName", + "Terraform": null, + "Required": false + }, + { + "ROS": "LaunchTemplateId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::LaunchTemplate" + } + ] + }, + { + "ROS": "LaunchTemplateName", + "Terraform": null, + "Required": false + }, + { + "ROS": "LaunchTemplateVersion", + "Terraform": null, + "Required": false + }, + { + "ROS": "LoadBalancerIdToAttach", + "Terraform": null, + "Required": false + }, + { + "ROS": "MaxAmount", + "Terraform": null, + "Required": true + }, + { + "ROS": "NetworkInterfaceQueueNumber", + "Terraform": null, + "Required": false + }, + { + "ROS": "NetworkOptions", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "EnableJumboFrame", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "Password", + "Terraform": null, + "Required": false + }, + { + "ROS": "PasswordInherit", + "Terraform": null, + "Required": false + }, + { + "ROS": "Period", + "Terraform": null, + "Required": false + }, + { + "ROS": "PeriodUnit", + "Terraform": null, + "Required": false + }, + { + "ROS": "RamRoleName", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "SecurityGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "SecurityGroupIds", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ], + "Properties": {}, + "Type": "list" + }, + { + "ROS": "SecurityOptions", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "TrustedSystemMode", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "SourceInstanceId", + "Terraform": null, + "Required": true + }, + { + "ROS": "SpotPriceLimit", + "Terraform": null, + "Required": false + }, + { + "ROS": "SpotStrategy", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskAutoSnapshotPolicyId", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskBurstingEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskCategory", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskDescription", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskDiskName", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskEncryptAlgorithm", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskEncrypted", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskKMSKeyId", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskProvisionedIops", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskStorageClusterId", + "Terraform": null, + "Required": false + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "UniqueSuffix", + "Terraform": null, + "Required": false + }, + { + "ROS": "UpdatePolicy", + "Terraform": null, + "Required": false + }, + { + "ROS": "ZoneId", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "HostNames", + "Terraform": null + }, + { + "ROS": "InnerIps", + "Terraform": null + }, + { + "ROS": "InstanceIds", + "Terraform": null + }, + { + "ROS": "Ipv6Addresses", + "Terraform": null + }, + { + "ROS": "Ipv6AddressIds", + "Terraform": null + }, + { + "ROS": "OrderId", + "Terraform": null + }, + { + "ROS": "PrivateIps", + "Terraform": null + }, + { + "ROS": "PublicIps", + "Terraform": null + }, + { + "ROS": "RelatedOrderIds", + "Terraform": null + }, + { + "ROS": "ZoneIds", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::Invocation", + "Terraform": "alicloud_ecs_invocation" + }, + "ProductCode": "ecs", + "Name": { + "zh": "云助手执行", + "en": "Cloud Assistant Invocation" + }, + "Properties": [ + { + "ROS": "CommandId", + "Terraform": "command_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Command" + }, + { + "ResourceType": "ROS/ALIYUN::ECS::RunCommand" + } + ] + }, + { + "ROS": "CommandName", + "Terraform": null, + "Required": false + }, + { + "ROS": "ContainerId", + "Terraform": null, + "Required": false + }, + { + "ROS": "ContainerName", + "Terraform": null, + "Required": false + }, + { + "ROS": "Frequency", + "Terraform": "frequency", + "Required": false + }, + { + "ROS": "InstanceIds", + "Terraform": "instance_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Instance" + }, + { + "ResourceType": "ROS/ALIYUN::ECS::InstanceGroup" + } + ] + }, + { + "ROS": "Parameters", + "Terraform": "parameters", + "Required": false + }, + { + "ROS": "RepeatMode", + "Terraform": "repeat_mode", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "Sync", + "Terraform": null, + "Required": false + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "Timed", + "Terraform": "timed", + "Required": false + }, + { + "ROS": "Timeout", + "Terraform": null, + "Required": false + }, + { + "ROS": "Username", + "Terraform": "username", + "Required": false + }, + { + "ROS": "WindowsPasswordName", + "Terraform": "windows_password_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "InvokeId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "InvokeInstances", + "Terraform": null + }, + { + "ROS": "InvokeResults", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::JoinSecurityGroup", + "Terraform": null + }, + "ProductCode": "ecs", + "Name": { + "zh": "加入安全组", + "en": "Add to Security Group" + }, + "Properties": [ + { + "ROS": "InstanceId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Instance" + }, + { + "ResourceType": "ROS/ALIYUN::ECS::InstanceGroup" + } + ] + }, + { + "ROS": "InstanceIdList", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Instance" + }, + { + "ResourceType": "ROS/ALIYUN::ECS::InstanceGroup" + } + ] + }, + { + "ROS": "NetworkInterfaceList", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::NetworkInterface" + } + ] + }, + { + "ROS": "SecurityGroupId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::LaunchTemplate", + "Terraform": "alicloud_ecs_launch_template" + }, + "ProductCode": "ecs", + "Name": { + "zh": "ECS启动模板", + "en": "ECS Launch Template" + }, + "Properties": [ + { + "ROS": "AutoReleaseTime", + "Terraform": "auto_release_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "auto_renew", + "Required": false + }, + { + "ROS": null, + "Terraform": "auto_renew_period", + "Required": false + }, + { + "ROS": "DiskMappings", + "Terraform": "data_disks", + "Required": false, + "Properties": [ + { + "ROS": "Category", + "Terraform": "category", + "Required": false + }, + { + "ROS": "DeleteWithInstance", + "Terraform": "delete_with_instance", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "device", + "Required": false + }, + { + "ROS": "Encrypted", + "Terraform": "encrypted", + "Required": false + }, + { + "ROS": null, + "Terraform": "name", + "Required": false + }, + { + "ROS": "PerformanceLevel", + "Terraform": "performance_level", + "Required": false + }, + { + "ROS": "Size", + "Terraform": "size", + "Required": false + }, + { + "ROS": "SnapshotId", + "Terraform": "snapshot_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Snapshot" + } + ] + } + ], + "Type": "list" + }, + { + "ROS": "DeploymentSetId", + "Terraform": "deployment_set_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::DeploymentSet" + } + ] + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "enable_vm_os_config", + "Required": false + }, + { + "ROS": "HostName", + "Terraform": "host_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "http_endpoint", + "Required": false + }, + { + "ROS": null, + "Terraform": "http_put_response_hop_limit", + "Required": false + }, + { + "ROS": null, + "Terraform": "http_tokens", + "Required": false + }, + { + "ROS": "ImageId", + "Terraform": "image_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::CustomImage" + } + ] + }, + { + "ROS": "ImageOwnerAlias", + "Terraform": "image_owner_alias", + "Required": false + }, + { + "ROS": "InstanceChargeType", + "Terraform": "instance_charge_type", + "Required": false + }, + { + "ROS": "InstanceName", + "Terraform": "instance_name", + "Required": false + }, + { + "ROS": "InstanceType", + "Terraform": "instance_type", + "Required": false + }, + { + "ROS": "InternetChargeType", + "Terraform": "internet_charge_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "internet_max_bandwidth_in", + "Required": false + }, + { + "ROS": "InternetMaxBandwidthOut", + "Terraform": "internet_max_bandwidth_out", + "Required": false + }, + { + "ROS": "IoOptimized", + "Terraform": "io_optimized", + "Required": false + }, + { + "ROS": "Ipv6AddressCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "KeyPairName", + "Terraform": "key_pair_name", + "Required": false + }, + { + "ROS": "LaunchTemplateName", + "Terraform": "launch_template_name", + "Required": true + }, + { + "ROS": "NetworkInterfaces", + "Terraform": "network_interfaces", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::NetworkInterface" + } + ], + "Properties": [ + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "name", + "Required": false + }, + { + "ROS": null, + "Terraform": "primary_ip", + "Required": false + }, + { + "ROS": "SecurityGroupId", + "Terraform": "security_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Type": "list" + }, + { + "ROS": "NetworkType", + "Terraform": "network_type", + "Required": false + }, + { + "ROS": "PasswordInherit", + "Terraform": "password_inherit", + "Required": false + }, + { + "ROS": "Period", + "Terraform": "period", + "Required": false + }, + { + "ROS": null, + "Terraform": "period_unit", + "Required": false + }, + { + "ROS": "PrivateIpAddress", + "Terraform": "private_ip_address", + "Required": false + }, + { + "ROS": "RamRoleName", + "Terraform": "ram_role_name", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "SecurityEnhancementStrategy", + "Terraform": "security_enhancement_strategy", + "Required": false + }, + { + "ROS": "SecurityGroupId", + "Terraform": "security_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "SecurityGroupIds", + "Terraform": "security_group_ids", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "SpotDuration", + "Terraform": "spot_duration", + "Required": false + }, + { + "ROS": "SpotPriceLimit", + "Terraform": "spot_price_limit", + "Required": false + }, + { + "ROS": "SpotStrategy", + "Terraform": "spot_strategy", + "Required": false + }, + { + "ROS": null, + "Terraform": "system_disk", + "Required": false + }, + { + "ROS": "SystemDiskCategory", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskDeleteWithInstance", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskDescription", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskDiskName", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskPerformanceLevel", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskSize", + "Terraform": null, + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "TemplateResourceGroupId", + "Terraform": "template_resource_group_id", + "Required": false + }, + { + "ROS": "TemplateTags", + "Terraform": "template_tags", + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": "Key", + "Required": false + }, + { + "ROS": "Value", + "Terraform": "Value", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "UserData", + "Terraform": "user_data", + "Required": false + }, + { + "ROS": "VersionDescription", + "Terraform": "version_description", + "Required": false + }, + { + "ROS": null, + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "ZoneId", + "Terraform": "zone_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "DefaultVersionNumber", + "Terraform": null + }, + { + "ROS": "LaunchTemplateId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "LatestVersionNumber", + "Terraform": null + }, + { + "ROS": "LaunchTemplateName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::NetworkInterface", + "Terraform": "alicloud_ecs_network_interface" + }, + "ProductCode": "ecs", + "Name": { + "zh": "网卡", + "en": "ENI" + }, + "Properties": [ + { + "ROS": "DeleteOnRelease", + "Terraform": null, + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_type", + "Required": false + }, + { + "ROS": "Ipv4PrefixCount", + "Terraform": "ipv4_prefix_count", + "Required": false + }, + { + "ROS": "Ipv4Prefixes", + "Terraform": "ipv4_prefixes", + "Required": false + }, + { + "ROS": "Ipv6AddressCount", + "Terraform": "ipv6_address_count", + "Required": false + }, + { + "ROS": "Ipv6Addresses", + "Terraform": "ipv6_addresses", + "Required": false + }, + { + "ROS": "Ipv6PrefixCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "Ipv6Prefixes", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "NetworkInterfaceName", + "Terraform": "network_interface_name", + "Required": false + }, + { + "ROS": "NetworkInterfaceTrafficMode", + "Terraform": "network_interface_traffic_mode", + "Required": false + }, + { + "ROS": "PrimaryIpAddress", + "Terraform": "primary_ip_address", + "Required": false + }, + { + "ROS": "PrivateIpAddresses", + "Terraform": "private_ip_addresses", + "Required": false + }, + { + "ROS": "QueueNumber", + "Terraform": "queue_number", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "RxQueueSize", + "Terraform": null, + "Required": false + }, + { + "ROS": "SecondaryPrivateIpAddressCount", + "Terraform": "secondary_private_ip_address_count", + "Required": false + }, + { + "ROS": "SecurityGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "SecurityGroupIds", + "Terraform": "security_group_ids", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "TxQueueSize", + "Terraform": null, + "Required": false + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": "NetworkInterfaceId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "MacAddress", + "Terraform": "mac" + }, + { + "ROS": "PrivateIpAddress", + "Terraform": null + }, + { + "ROS": "SecondaryPrivateIpAddresses", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::NetworkInterfaceAttachment", + "Terraform": "alicloud_ecs_network_interface_attachment" + }, + "MainResourceType": { + "ResourceType": "ROS/ALIYUN::ECS::NetworkInterface", + "RefProperty": "ROS/NetworkInterfaceId" + }, + "ProductCode": "ecs", + "Name": { + "zh": "绑定网卡", + "en": "Attach ENI" + }, + "Properties": [ + { + "ROS": "EcsRestartOption", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceId", + "Terraform": "instance_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Instance" + }, + { + "ResourceType": "ROS/ALIYUN::ECS::InstanceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "network_card_index", + "Required": false + }, + { + "ROS": "NetworkInterfaceId", + "Terraform": "network_interface_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::NetworkInterface" + } + ] + }, + { + "ROS": "TrunkNetworkInstanceId", + "Terraform": "trunk_network_instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "wait_for_network_configuration_ready", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "InstanceId", + "Terraform": null + }, + { + "ROS": "NetworkInterfaceId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::NetworkInterface" + } + ] + }, + { + "ROS": "TrunkNetworkInstanceId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::NetworkInterfacePermission", + "Terraform": "alicloud_ecs_network_interface_permission" + }, + "ProductCode": "ecs", + "Name": { + "zh": "授权网卡", + "en": "Grant Permissions on ENI" + }, + "Properties": [ + { + "ROS": "AccountId", + "Terraform": "account_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::Account" + } + ] + }, + { + "ROS": null, + "Terraform": "force", + "Required": false + }, + { + "ROS": "NetworkInterfaceId", + "Terraform": "network_interface_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::NetworkInterface" + } + ] + }, + { + "ROS": "Permission", + "Terraform": "permission", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "NetworkInterfacePermissionId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::PrefixList", + "Terraform": "alicloud_ecs_prefix_list" + }, + "ProductCode": "ecs", + "Name": { + "zh": "ECS前缀列表", + "en": "ECS Prefix List" + }, + "Properties": [ + { + "ROS": "AddressFamily", + "Terraform": "address_family", + "Required": true + }, + { + "ROS": null, + "Terraform": "cidr", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "Entries", + "Terraform": "entry", + "Required": false, + "Properties": [ + { + "ROS": "Cidr", + "Terraform": "cidr", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + } + ] + }, + { + "ROS": "MaxEntries", + "Terraform": "max_entries", + "Required": true + }, + { + "ROS": "PrefixListName", + "Terraform": "prefix_list_name", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "PrefixListId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::RamRoleAttachment", + "Terraform": null + }, + "ProductCode": "ecs", + "Name": { + "zh": "授予ECS实例RAM角色", + "en": "Assign ECS Instance RAM Role" + }, + "Properties": [ + { + "ROS": "InstanceIds", + "Terraform": null, + "Required": true, + "Properties": {}, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Instance" + }, + { + "ResourceType": "ROS/ALIYUN::ECS::InstanceGroup" + } + ], + "Type": "list" + }, + { + "ROS": "Policy", + "Terraform": null, + "Required": false + }, + { + "ROS": "RamRoleName", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "InstanceIds", + "Terraform": null + }, + { + "ROS": "RamRoleName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::Route", + "Terraform": "alicloud_route_entry" + }, + "ProductCode": "ecs", + "Name": { + "zh": "路由", + "en": "Route" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": "DestinationCidrBlock", + "Terraform": "destination_cidrblock", + "Required": true + }, + { + "ROS": null, + "Terraform": "name", + "Required": false + }, + { + "ROS": "NextHopId", + "Terraform": "nexthop_id", + "Required": false + }, + { + "ROS": "NextHopList", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "NextHopId", + "Terraform": null, + "Required": true + }, + { + "ROS": "NextHopType", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "NextHopType", + "Terraform": "nexthop_type", + "Required": false + }, + { + "ROS": "RouteTableId", + "Terraform": "route_table_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ], + "Attributes": [ + { + "ROS": "RouteEntryId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::RunCommand", + "Terraform": null + }, + "ProductCode": "ecs", + "Name": { + "zh": "执行云助手命令", + "en": "Run Cloud Assistant Command" + }, + "Properties": [ + { + "ROS": "CommandContent", + "Terraform": null, + "Required": true + }, + { + "ROS": "ContainerId", + "Terraform": null, + "Required": false + }, + { + "ROS": "ContainerName", + "Terraform": null, + "Required": false + }, + { + "ROS": "ContentEncoding", + "Terraform": null, + "Required": false + }, + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "EnableParameter", + "Terraform": null, + "Required": false + }, + { + "ROS": "Frequency", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceIds", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Instance" + }, + { + "ResourceType": "ROS/ALIYUN::ECS::InstanceGroup" + } + ], + "Properties": {}, + "Type": "list" + }, + { + "ROS": "KeepCommand", + "Terraform": null, + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": false + }, + { + "ROS": "Parameters", + "Terraform": null, + "Required": false + }, + { + "ROS": "RepeatMode", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "RunAgainOn", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "Sync", + "Terraform": null, + "Required": false + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "Timeout", + "Terraform": null, + "Required": false + }, + { + "ROS": "Type", + "Terraform": null, + "Required": true + }, + { + "ROS": "Username", + "Terraform": null, + "Required": false + }, + { + "ROS": "WindowsPasswordName", + "Terraform": null, + "Required": false + }, + { + "ROS": "WorkingDir", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "CommandId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "InvokeId", + "Terraform": null + }, + { + "ROS": "InvokeInstances", + "Terraform": null + }, + { + "ROS": "InvokeResults", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::SNatEntry", + "Terraform": "alicloud_snat_entry" + }, + "ProductCode": "ecs", + "Name": { + "zh": "SNAT表", + "en": "SNAT Table" + }, + "Properties": [ + { + "ROS": "SnatEntryName", + "Terraform": "snat_entry_name", + "Required": false + }, + { + "ROS": "SNatIp", + "Terraform": "snat_ip", + "Required": true + }, + { + "ROS": "SNatTableId", + "Terraform": "snat_table_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::NatGateway" + } + ] + }, + { + "ROS": "SourceCIDR", + "Terraform": "source_cidr", + "Required": false + }, + { + "ROS": "SourceVSwitchId", + "Terraform": "source_vswitch_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "SNatEntryId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "snat_entry_id" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::SSHKeyPair", + "Terraform": "alicloud_ecs_key_pair" + }, + "ProductCode": "ecs", + "Name": { + "zh": "密钥对", + "en": "Key Pair" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "key_file", + "Required": false + }, + { + "ROS": null, + "Terraform": "key_name_prefix", + "Required": false + }, + { + "ROS": "KeyPairName", + "Terraform": "key_pair_name", + "Required": true + }, + { + "ROS": "PublicKeyBody", + "Terraform": "public_key", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "finger_print" + }, + { + "ROS": "KeyPairName", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "KeyPairFingerPrint", + "Terraform": null + }, + { + "ROS": "PrivateKeyBody", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::SSHKeyPairAttachment", + "Terraform": "alicloud_ecs_key_pair_attachment" + }, + "MainResourceType": { + "ResourceType": "ROS/ALIYUN::ECS::SSHKeyPair", + "RefProperty": "ROS/KeyPairName" + }, + "ProductCode": "ecs", + "Name": { + "zh": "绑定密钥对", + "en": "Attach Key Pair" + }, + "Properties": [ + { + "ROS": "AutoReboot", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "force", + "Required": false + }, + { + "ROS": "InstanceIds", + "Terraform": "instance_ids", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Instance" + }, + { + "ResourceType": "ROS/ALIYUN::ECS::InstanceGroup" + } + ] + }, + { + "ROS": "KeyPairName", + "Terraform": "key_pair_name", + "Required": true + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::SecurityGroup", + "Terraform": "alicloud_security_group" + }, + "ProductCode": "ecs", + "Name": { + "zh": "安全组", + "en": "Security Group" + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "inner_access_policy", + "Required": false + }, + { + "ROS": "SecurityGroupName", + "Terraform": "name", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "SecurityGroupEgress", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "DestCidrIp", + "Terraform": null, + "Required": false + }, + { + "ROS": "DestGroupId", + "Terraform": null, + "Required": false + }, + { + "ROS": "DestGroupOwnerAccount", + "Terraform": null, + "Required": false + }, + { + "ROS": "DestGroupOwnerId", + "Terraform": null, + "Required": false + }, + { + "ROS": "DestPrefixListId", + "Terraform": null, + "Required": false + }, + { + "ROS": "IpProtocol", + "Terraform": null, + "Required": true + }, + { + "ROS": "Ipv6DestCidrIp", + "Terraform": null, + "Required": false + }, + { + "ROS": "Ipv6SourceCidrIp", + "Terraform": null, + "Required": false + }, + { + "ROS": "NicType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Policy", + "Terraform": null, + "Required": false + }, + { + "ROS": "PortRange", + "Terraform": null, + "Required": true + }, + { + "ROS": "Priority", + "Terraform": null, + "Required": false + }, + { + "ROS": "SourceCidrIp", + "Terraform": null, + "Required": false + }, + { + "ROS": "SourcePortRange", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "SecurityGroupIngress", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "DestCidrIp", + "Terraform": null, + "Required": false + }, + { + "ROS": "IpProtocol", + "Terraform": null, + "Required": true + }, + { + "ROS": "Ipv6DestCidrIp", + "Terraform": null, + "Required": false + }, + { + "ROS": "Ipv6SourceCidrIp", + "Terraform": null, + "Required": false + }, + { + "ROS": "NicType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Policy", + "Terraform": null, + "Required": false + }, + { + "ROS": "PortRange", + "Terraform": null, + "Required": true + }, + { + "ROS": "Priority", + "Terraform": null, + "Required": false + }, + { + "ROS": "SourceCidrIp", + "Terraform": null, + "Required": false + }, + { + "ROS": "SourceGroupId", + "Terraform": null, + "Required": false + }, + { + "ROS": "SourceGroupOwnerAccount", + "Terraform": null, + "Required": false + }, + { + "ROS": "SourceGroupOwnerId", + "Terraform": null, + "Required": false + }, + { + "ROS": "SourcePortRange", + "Terraform": null, + "Required": false + }, + { + "ROS": "SourcePrefixListId", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "SecurityGroupType", + "Terraform": "security_group_type", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ], + "Attributes": [ + { + "ROS": "SecurityGroupId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "SecurityGroupName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::SecurityGroupClone", + "Terraform": null + }, + "ProductCode": "ecs", + "Name": { + "zh": "克隆安全组", + "en": "Clone Security Group" + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "DestinationRegionId", + "Terraform": null, + "Required": false + }, + { + "ROS": "NetworkType", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "SecurityGroupName", + "Terraform": null, + "Required": false + }, + { + "ROS": "SecurityGroupType", + "Terraform": null, + "Required": false + }, + { + "ROS": "SourceSecurityGroupId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "VpcId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ], + "Attributes": [ + { + "ROS": "SecurityGroupId", + "Terraform": null, + "Primary": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::SecurityGroupEgress", + "Terraform": null + }, + "ProductCode": "ecs", + "Name": { + "zh": "安全组出规则", + "en": "Security Group Outbound Rule" + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "DestCidrIp", + "Terraform": null, + "Required": false + }, + { + "ROS": "DestGroupId", + "Terraform": null, + "Required": false + }, + { + "ROS": "DestGroupOwnerId", + "Terraform": null, + "Required": false + }, + { + "ROS": "DestPrefixListId", + "Terraform": null, + "Required": false + }, + { + "ROS": "IpProtocol", + "Terraform": null, + "Required": true + }, + { + "ROS": "Ipv6DestCidrIp", + "Terraform": null, + "Required": false + }, + { + "ROS": "NicType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Policy", + "Terraform": null, + "Required": false + }, + { + "ROS": "PortRange", + "Terraform": null, + "Required": true + }, + { + "ROS": "Priority", + "Terraform": null, + "Required": false + }, + { + "ROS": "SecurityGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::SecurityGroupEgresses", + "Terraform": null + }, + "ProductCode": "ecs", + "Name": { + "zh": "ECS安全组出方向访问规则", + "en": "ECS Security Group Outbound Rules" + }, + "Properties": [ + { + "ROS": "Permissions", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "DestCidrIp", + "Terraform": null, + "Required": false + }, + { + "ROS": "DestGroupId", + "Terraform": null, + "Required": false + }, + { + "ROS": "DestGroupOwnerAccount", + "Terraform": null, + "Required": false + }, + { + "ROS": "DestGroupOwnerId", + "Terraform": null, + "Required": false + }, + { + "ROS": "DestPrefixListId", + "Terraform": null, + "Required": false + }, + { + "ROS": "IpProtocol", + "Terraform": null, + "Required": true + }, + { + "ROS": "Ipv6DestCidrIp", + "Terraform": null, + "Required": false + }, + { + "ROS": "Ipv6SourceCidrIp", + "Terraform": null, + "Required": false + }, + { + "ROS": "NicType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Policy", + "Terraform": null, + "Required": false + }, + { + "ROS": "PortRange", + "Terraform": null, + "Required": true + }, + { + "ROS": "Priority", + "Terraform": null, + "Required": false + }, + { + "ROS": "SourceCidrIp", + "Terraform": null, + "Required": false + }, + { + "ROS": "SourcePortRange", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "SecurityGroupId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::SecurityGroupIngress", + "Terraform": "alicloud_security_group_rule" + }, + "ProductCode": "ecs", + "Name": { + "zh": "安全组入规则", + "en": "Security Group Inbound Rule" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "cidr_ip", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "IpProtocol", + "Terraform": "ip_protocol", + "Required": true + }, + { + "ROS": null, + "Terraform": "ipv6_cidr_ip", + "Required": false + }, + { + "ROS": "Ipv6SourceCidrIp", + "Terraform": null, + "Required": false + }, + { + "ROS": "NicType", + "Terraform": "nic_type", + "Required": false + }, + { + "ROS": "Policy", + "Terraform": "policy", + "Required": false + }, + { + "ROS": "PortRange", + "Terraform": "port_range", + "Required": true + }, + { + "ROS": null, + "Terraform": "prefix_list_id", + "Required": false + }, + { + "ROS": "Priority", + "Terraform": "priority", + "Required": false + }, + { + "ROS": "SecurityGroupId", + "Terraform": "security_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "SourceCidrIp", + "Terraform": null, + "Required": false + }, + { + "ROS": "SourceGroupId", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "source_group_owner_account", + "Required": false + }, + { + "ROS": "SourceGroupOwnerId", + "Terraform": null, + "Required": false + }, + { + "ROS": "SourcePortRange", + "Terraform": null, + "Required": false + }, + { + "ROS": "SourcePrefixListId", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "source_security_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::SecurityGroupIngresses", + "Terraform": null + }, + "ProductCode": "ecs", + "Name": { + "zh": "ECS安全组入方向访问规则", + "en": "ECS Security Group Inbound Rules" + }, + "Properties": [ + { + "ROS": "Permissions", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "DestCidrIp", + "Terraform": null, + "Required": false + }, + { + "ROS": "IpProtocol", + "Terraform": null, + "Required": true + }, + { + "ROS": "Ipv6DestCidrIp", + "Terraform": null, + "Required": false + }, + { + "ROS": "Ipv6SourceCidrIp", + "Terraform": null, + "Required": false + }, + { + "ROS": "NicType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Policy", + "Terraform": null, + "Required": false + }, + { + "ROS": "PortRange", + "Terraform": null, + "Required": true + }, + { + "ROS": "Priority", + "Terraform": null, + "Required": false + }, + { + "ROS": "SourceCidrIp", + "Terraform": null, + "Required": false + }, + { + "ROS": "SourceGroupId", + "Terraform": null, + "Required": false + }, + { + "ROS": "SourceGroupOwnerAccount", + "Terraform": null, + "Required": false + }, + { + "ROS": "SourceGroupOwnerId", + "Terraform": null, + "Required": false + }, + { + "ROS": "SourcePortRange", + "Terraform": null, + "Required": false + }, + { + "ROS": "SourcePrefixListId", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "SecurityGroupId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::Snapshot", + "Terraform": "alicloud_ecs_snapshot" + }, + "ProductCode": "ecs", + "Name": { + "zh": "快照", + "en": "Snapshot" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "category", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "DiskId", + "Terraform": "disk_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Disk" + } + ] + }, + { + "ROS": null, + "Terraform": "force", + "Required": false + }, + { + "ROS": "InstantAccess", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstantAccessRetentionDays", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "RetentionDays", + "Terraform": "retention_days", + "Required": false + }, + { + "ROS": "SnapshotName", + "Terraform": "snapshot_name", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "Timeout", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": "SnapshotId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::SnapshotGroup", + "Terraform": "alicloud_ecs_snapshot_group" + }, + "ProductCode": "ecs", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "DiskIds", + "Terraform": "disk_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Disk" + } + ] + }, + { + "ROS": "DiskIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Disk" + } + ], + "Type": "list" + }, + { + "ROS": "ExcludeDiskIds", + "Terraform": "exclude_disk_id", + "Required": false + }, + { + "ROS": "ExcludeDiskIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "InstanceId", + "Terraform": "instance_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Instance" + }, + { + "ResourceType": "ROS/ALIYUN::ECS::InstanceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "instant_access", + "Required": false + }, + { + "ROS": null, + "Terraform": "instant_access_retention_days", + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "snapshot_group_name", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "SnapshotGroupId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ecs_auto_snapshot_policy_attachment" + }, + "MainResourceType": { + "ResourceType": "ROS/ALIYUN::ECS::AutoSnapshotPolicy", + "RefProperty": "ROS/AutoSnapshotPolicyId" + }, + "ProductCode": "ecs", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "auto_snapshot_policy_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::AutoSnapshotPolicy" + } + ] + }, + { + "ROS": null, + "Terraform": "disk_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Disk" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ecs_dedicated_host_cluster" + }, + "ProductCode": "ecs", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "dedicated_host_cluster_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": null, + "Terraform": "zone_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ecs_session_manager_status" + }, + "ProductCode": "ecs", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "session_manager_status_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ecs_storage_capacity_unit" + }, + "ProductCode": "ecs", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "capacity", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "period", + "Required": false + }, + { + "ROS": null, + "Terraform": "period_unit", + "Required": false + }, + { + "ROS": null, + "Terraform": "start_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "storage_capacity_unit_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::VPC", + "Terraform": "alicloud_vpc" + }, + "ProductCode": "vpc", + "Name": { + "zh": "专有网络VPC", + "en": "VPC" + }, + "Properties": [ + { + "ROS": "CidrBlock", + "Terraform": "cidr_block", + "Required": false + }, + { + "ROS": null, + "Terraform": "classic_link_enabled", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": "EnableIpv6", + "Terraform": "enable_ipv6", + "Required": false + }, + { + "ROS": null, + "Terraform": "ipv4_ipam_pool_id", + "Required": false + }, + { + "ROS": "Ipv6CidrBlock", + "Terraform": "ipv6_cidr_block", + "Required": false + }, + { + "ROS": "Ipv6Isp", + "Terraform": "ipv6_isp", + "Required": false + }, + { + "ROS": null, + "Terraform": "is_default", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "route_table_id", + "Required": false + }, + { + "ROS": "SecondaryCidrBlocks", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": null, + "Terraform": "system_route_table_description", + "Required": false + }, + { + "ROS": null, + "Terraform": "system_route_table_name", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "UserCidr", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "user_cidrs", + "Required": false + }, + { + "ROS": "VpcName", + "Terraform": "vpc_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "VpcId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "ipv6_cidr_blocks" + }, + { + "ROS": null, + "Terraform": "router_id" + }, + { + "ROS": "RouteTableId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "VpcName", + "Terraform": null + }, + { + "ROS": "VRouterId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECS::VSwitch", + "Terraform": "alicloud_vswitch" + }, + "ProductCode": "vpc", + "Name": { + "zh": "交换机", + "en": "VSwitch" + }, + "Properties": [ + { + "ROS": "CidrBlock", + "Terraform": "cidr_block", + "Required": true + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "enable_ipv6", + "Required": false + }, + { + "ROS": "Ipv6CidrBlock", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "ipv6_cidr_block_mask", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VpcIpv6CidrBlock", + "Terraform": null, + "Required": false + }, + { + "ROS": "VSwitchName", + "Terraform": "vswitch_name", + "Required": false + }, + { + "ROS": "ZoneId", + "Terraform": "zone_id", + "Required": true, + "RelatedTo": [ + { + "DataSourceType": "ROS/DATASOURCE::VPC::Zones" + } + ] + }, + { + "ROS": "ZoneType", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "CidrBlock", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "VSwitchId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "Ipv6CidrBlock", + "Terraform": "ipv6_cidr_block" + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "VSwitchName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::BgpGroup", + "Terraform": "alicloud_vpc_bgp_group" + }, + "ProductCode": "vpc", + "Name": { + "zh": "BGP组", + "en": "BGP Group" + }, + "Properties": [ + { + "ROS": "AuthKey", + "Terraform": "auth_key", + "Required": false + }, + { + "ROS": "Name", + "Terraform": "bgp_group_name", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "IpVersion", + "Terraform": null, + "Required": false + }, + { + "ROS": "IsFakeAsn", + "Terraform": "is_fake_asn", + "Required": false + }, + { + "ROS": "LocalAsn", + "Terraform": "local_asn", + "Required": false + }, + { + "ROS": "PeerAsn", + "Terraform": "peer_asn", + "Required": true + }, + { + "ROS": "RouteQuota", + "Terraform": null, + "Required": false + }, + { + "ROS": "RouterId", + "Terraform": "router_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::VirtualBorderRouter" + } + ] + } + ], + "Attributes": [ + { + "ROS": "BgpGroupId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "Name", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::BgpNetwork", + "Terraform": "alicloud_vpc_bgp_network" + }, + "ProductCode": "vpc", + "Name": { + "zh": "BGP网络", + "en": "BGP Network" + }, + "Properties": [ + { + "ROS": "DstCidrBlock", + "Terraform": "dst_cidr_block", + "Required": true + }, + { + "ROS": "RouterId", + "Terraform": "router_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::VirtualBorderRouter" + } + ] + } + ], + "Attributes": [ + { + "ROS": "DstCidrBlock", + "Terraform": null + }, + { + "ROS": "RouterId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::BgpPeer", + "Terraform": "alicloud_vpc_bgp_peer" + }, + "ProductCode": "vpc", + "Name": { + "zh": "BGP邻居", + "en": "BGP Peer" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "bfd_multi_hop", + "Required": false + }, + { + "ROS": "BgpGroupId", + "Terraform": "bgp_group_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::BgpGroup" + } + ] + }, + { + "ROS": "EnableBfd", + "Terraform": "enable_bfd", + "Required": false + }, + { + "ROS": null, + "Terraform": "ip_version", + "Required": false + }, + { + "ROS": "PeerIpAddress", + "Terraform": "peer_ip_address", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "bgp_peer_name" + }, + { + "ROS": "BgpPeerId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::CustomerGateway", + "Terraform": "alicloud_vpn_customer_gateway" + }, + "ProductCode": "vpc", + "Name": { + "zh": "用户网关", + "en": "Customer Gateway" + }, + "Properties": [ + { + "ROS": "Asn", + "Terraform": "asn", + "Required": false + }, + { + "ROS": null, + "Terraform": "customer_gateway_name", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "IpAddress", + "Terraform": "ip_address", + "Required": true + }, + { + "ROS": "Name", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "CustomerGatewayId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::DhcpOptionsSet", + "Terraform": "alicloud_vpc_dhcp_options_set" + }, + "ProductCode": "vpc", + "Name": { + "zh": "DHCP选项集", + "en": "DHCP Option Set" + }, + "Properties": [ + { + "ROS": "DhcpOptionsSetDescription", + "Terraform": "dhcp_options_set_description", + "Required": false + }, + { + "ROS": "DhcpOptionsSetName", + "Terraform": "dhcp_options_set_name", + "Required": false + }, + { + "ROS": "DomainName", + "Terraform": "domain_name", + "Required": false + }, + { + "ROS": "DomainNameServers", + "Terraform": "domain_name_servers", + "Required": false + }, + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": null, + "Terraform": "ipv6_lease_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "lease_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "DhcpOptionsSetId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "owner_id" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::DhcpOptionsSetAttachment", + "Terraform": "alicloud_vpc_dhcp_options_set_attachment" + }, + "MainResourceType": { + "ResourceType": "ROS/ALIYUN::VPC::DhcpOptionsSet", + "RefProperty": "ROS/DhcpOptionsSetId" + }, + "ProductCode": "vpc", + "Name": { + "zh": "DHCP选项集关联", + "en": "Associate DHCP Option Set" + }, + "Properties": [ + { + "ROS": "DhcpOptionsSetId", + "Terraform": "dhcp_options_set_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::DhcpOptionsSet" + } + ] + }, + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ], + "Attributes": [ + { + "ROS": "DhcpOptionsSetId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "VpcId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::FlowLog", + "Terraform": "alicloud_cen_flowlog" + }, + "ProductCode": "vpc", + "Name": { + "zh": "流日志", + "en": "Flow Log" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "aggregation_interval", + "Required": false + }, + { + "ROS": null, + "Terraform": "cen_id", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "FlowLogName", + "Terraform": "flow_log_name", + "Required": false + }, + { + "ROS": "LogStoreName", + "Terraform": "log_store_name", + "Required": true + }, + { + "ROS": "ProjectName", + "Terraform": "project_name", + "Required": true + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "ResourceId", + "Terraform": "resource_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + }, + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + }, + { + "ResourceType": "ROS/ALIYUN::ECS::NetworkInterface" + } + ] + }, + { + "ROS": "ResourceType", + "Terraform": "resource_type", + "Required": true + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": null, + "Terraform": "traffic_path", + "Required": false + }, + { + "ROS": "TrafficType", + "Terraform": "traffic_type", + "Required": true + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "business_status" + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "Description", + "Terraform": null + }, + { + "ROS": "FlowLogId", + "Terraform": "flow_log_id" + }, + { + "ROS": "FlowLogName", + "Terraform": null + }, + { + "ROS": "FlowLogId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "LogStoreName", + "Terraform": null + }, + { + "ROS": "ProjectName", + "Terraform": null + }, + { + "ROS": "ResourceId", + "Terraform": null + }, + { + "ROS": "ResourceType", + "Terraform": null + }, + { + "ROS": "TrafficType", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::GrantInstanceToCen", + "Terraform": "alicloud_cen_instance_grant" + }, + "ProductCode": "vpc", + "Name": { + "zh": "为云企业网实例授权", + "en": "Authorize CEN Instance" + }, + "Properties": [ + { + "ROS": "CenId", + "Terraform": "cen_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::CenInstance" + } + ] + }, + { + "ROS": "CenOwnerId", + "Terraform": "cen_owner_id", + "Required": true + }, + { + "ROS": null, + "Terraform": "child_instance_id", + "Required": false + }, + { + "ROS": "InstanceId", + "Terraform": "instance_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::NetworkInterface" + } + ] + }, + { + "ROS": "InstanceType", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "CenId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "InstanceId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::HaVip", + "Terraform": "alicloud_havip" + }, + "ProductCode": "vpc", + "Name": { + "zh": "高可用虚拟IP", + "en": "HAVIP" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "associated_eip_addresses", + "Required": false + }, + { + "ROS": null, + "Terraform": "associated_instances", + "Required": false + }, + { + "ROS": null, + "Terraform": "associated_instance_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "create_time", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "ha_vip_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::HaVip" + } + ] + }, + { + "ROS": "Name", + "Terraform": "ha_vip_name", + "Required": false + }, + { + "ROS": "IpAddress", + "Terraform": "ip_address", + "Required": false + }, + { + "ROS": null, + "Terraform": "master_instance_id", + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": null, + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "associated_eip_addresses" + }, + { + "ROS": null, + "Terraform": "associated_instances" + }, + { + "ROS": null, + "Terraform": "associated_instance_type" + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "HaVipId", + "Terraform": "ha_vip_id" + }, + { + "ROS": "HaVipId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "IpAddress", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "master_instance_id" + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": null, + "Terraform": "vpc_id", + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::HaVipAssociation", + "Terraform": "alicloud_havip_attachment" + }, + "MainResourceType": { + "ResourceType": "ROS/ALIYUN::VPC::HaVip", + "RefProperty": "ROS/HaVipId" + }, + "ProductCode": "vpc", + "Name": { + "zh": "绑定高可用虚拟IP", + "en": "Associate HAVIP" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "force", + "Required": false + }, + { + "ROS": "HaVipId", + "Terraform": "ha_vip_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::HaVip" + } + ] + }, + { + "ROS": "InstanceId", + "Terraform": "instance_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Instance" + }, + { + "ResourceType": "ROS/ALIYUN::ECS::InstanceGroup" + } + ] + }, + { + "ROS": "InstanceType", + "Terraform": "instance_type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::Ipam", + "Terraform": null + }, + "ProductCode": "vpc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "IpamDescription", + "Terraform": null, + "Required": false + }, + { + "ROS": "IpamName", + "Terraform": null, + "Required": false + }, + { + "ROS": "OperatingRegionList", + "Terraform": null, + "Required": true, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "CreateTime", + "Terraform": null + }, + { + "ROS": "DefaultResourceDiscoveryAssociationId", + "Terraform": null + }, + { + "ROS": "DefaultResourceDiscoveryId", + "Terraform": null + }, + { + "ROS": "IpamDescription", + "Terraform": null + }, + { + "ROS": "IpamId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "IpamName", + "Terraform": null + }, + { + "ROS": "OperatingRegionList", + "Terraform": null + }, + { + "ROS": "PrivateDefaultScopeId", + "Terraform": null + }, + { + "ROS": "PublicDefaultScopeId", + "Terraform": null + }, + { + "ROS": "ResourceDiscoveryAssociationCount", + "Terraform": null + }, + { + "ROS": "ResourceGroupId", + "Terraform": null + }, + { + "ROS": "Tags", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::IpamScope", + "Terraform": null + }, + "ProductCode": "vpc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "IpamId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::Ipam" + } + ] + }, + { + "ROS": "IpamScopeDescription", + "Terraform": null, + "Required": false + }, + { + "ROS": "IpamScopeName", + "Terraform": null, + "Required": false + }, + { + "ROS": "IpamScopeType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "CreateTime", + "Terraform": null + }, + { + "ROS": "IpamId", + "Terraform": null + }, + { + "ROS": "IpamScopeDescription", + "Terraform": null + }, + { + "ROS": "IpamScopeId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "IpamScopeName", + "Terraform": null + }, + { + "ROS": "IpamScopeType", + "Terraform": null + }, + { + "ROS": "Tags", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::IpsecServer", + "Terraform": "alicloud_vpn_ipsec_server" + }, + "ProductCode": "vpc", + "Name": { + "zh": "IPsec服务端", + "en": "IPsec-VPN Server" + }, + "Properties": [ + { + "ROS": "ClientIpPool", + "Terraform": "client_ip_pool", + "Required": true + }, + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": "EffectImmediately", + "Terraform": "effect_immediately", + "Required": false + }, + { + "ROS": "IkeConfig", + "Terraform": "ike_config", + "Required": false, + "Properties": [ + { + "ROS": "IkeAuthAlg", + "Terraform": "ike_auth_alg", + "Required": false + }, + { + "ROS": "IkeEncAlg", + "Terraform": "ike_enc_alg", + "Required": false + }, + { + "ROS": "IkeLifetime", + "Terraform": "ike_lifetime", + "Required": false + }, + { + "ROS": "IkeMode", + "Terraform": "ike_mode", + "Required": false + }, + { + "ROS": "IkePfs", + "Terraform": "ike_pfs", + "Required": false + }, + { + "ROS": "IkeVersion", + "Terraform": "ike_version", + "Required": false + }, + { + "ROS": "LocalId", + "Terraform": "local_id", + "Required": false + }, + { + "ROS": "RemoteId", + "Terraform": "remote_id", + "Required": false + } + ] + }, + { + "ROS": "IpsecConfig", + "Terraform": "ipsec_config", + "Required": false, + "Properties": [ + { + "ROS": "IpsecAuthAlg", + "Terraform": "ipsec_auth_alg", + "Required": false + }, + { + "ROS": "IpsecEncAlg", + "Terraform": "ipsec_enc_alg", + "Required": false + }, + { + "ROS": "IpsecLifetime", + "Terraform": "ipsec_lifetime", + "Required": false + }, + { + "ROS": "IpsecPfs", + "Terraform": "ipsec_pfs", + "Required": false + } + ] + }, + { + "ROS": "IpsecServerName", + "Terraform": "ipsec_server_name", + "Required": false + }, + { + "ROS": "LocalSubnet", + "Terraform": "local_subnet", + "Required": true + }, + { + "ROS": "Psk", + "Terraform": "psk", + "Required": false + }, + { + "ROS": "PskEnabled", + "Terraform": "psk_enabled", + "Required": false + }, + { + "ROS": "VpnGatewayId", + "Terraform": "vpn_gateway_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::VpnGateway" + } + ] + } + ], + "Attributes": [ + { + "ROS": "IpsecServerId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "IpsecServerName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::Ipv4Gateway", + "Terraform": "alicloud_vpc_ipv4_gateway" + }, + "ProductCode": "vpc", + "Name": { + "zh": "IPv4网关", + "en": "IPv4 Gateway" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": null, + "Terraform": "enabled", + "Required": false + }, + { + "ROS": "Ipv4GatewayDescription", + "Terraform": "ipv4_gateway_description", + "Required": false + }, + { + "ROS": "Ipv4GatewayName", + "Terraform": "ipv4_gateway_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ], + "Attributes": [ + { + "ROS": "CreateTime", + "Terraform": "create_time" + }, + { + "ROS": "Ipv4GatewayId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "Ipv4GatewayDescription", + "Terraform": null + }, + { + "ROS": "Ipv4GatewayId", + "Terraform": "ipv4_gateway_id" + }, + { + "ROS": "Ipv4GatewayName", + "Terraform": null + }, + { + "ROS": "Ipv4GatewayRouteTableId", + "Terraform": "ipv4_gateway_route_table_id" + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "VpcId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::Ipv6Gateway", + "Terraform": "alicloud_vpc_ipv6_gateway" + }, + "ProductCode": "vpc", + "Name": { + "zh": "IPv6网关", + "en": "IPv6 Gateway" + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "ipv6_gateway_name", + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "Spec", + "Terraform": null, + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "business_status" + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "expired_time" + }, + { + "ROS": "Ipv6GatewayId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "instance_charge_type" + }, + { + "ROS": "Ipv6GatewayId", + "Terraform": "ipv6_gateway_id" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::Ipv6InternetBandwidth", + "Terraform": "alicloud_vpc_ipv6_internet_bandwidth" + }, + "ProductCode": "vpc", + "Name": { + "zh": "IPv6公网带宽", + "en": "IPv6 Internet Bandwidth" + }, + "Properties": [ + { + "ROS": "Bandwidth", + "Terraform": "bandwidth", + "Required": true + }, + { + "ROS": "InternetChargeType", + "Terraform": "internet_charge_type", + "Required": false + }, + { + "ROS": "Ipv6AddressId", + "Terraform": "ipv6_address_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::AssignIpv6Addresses" + } + ] + }, + { + "ROS": "Ipv6GatewayId", + "Terraform": "ipv6_gateway_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::Ipv6Gateway" + } + ] + } + ], + "Attributes": [ + { + "ROS": "InternetBandwidthId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::NetworkAcl", + "Terraform": "alicloud_network_acl" + }, + "ProductCode": "vpc", + "Name": { + "zh": "网络ACL", + "en": "Network ACL" + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "EgressAclEntries", + "Terraform": "egress_acl_entries", + "Required": false, + "Properties": [ + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "DestinationCidrIp", + "Terraform": "destination_cidr_ip", + "Required": false + }, + { + "ROS": "EntryType", + "Terraform": "entry_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "ip_version", + "Required": false + }, + { + "ROS": "NetworkAclEntryName", + "Terraform": "network_acl_entry_name", + "Required": false + }, + { + "ROS": "Policy", + "Terraform": "policy", + "Required": true + }, + { + "ROS": "Port", + "Terraform": "port", + "Required": true + }, + { + "ROS": "Protocol", + "Terraform": "protocol", + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "IngressAclEntries", + "Terraform": "ingress_acl_entries", + "Required": false, + "Properties": [ + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "EntryType", + "Terraform": "entry_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "ip_version", + "Required": false + }, + { + "ROS": "NetworkAclEntryName", + "Terraform": "network_acl_entry_name", + "Required": false + }, + { + "ROS": "Policy", + "Terraform": "policy", + "Required": true + }, + { + "ROS": "Port", + "Terraform": "port", + "Required": true + }, + { + "ROS": "Protocol", + "Terraform": "protocol", + "Required": true + }, + { + "ROS": "SourceCidrIp", + "Terraform": "source_cidr_ip", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "NetworkAclName", + "Terraform": "network_acl_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "resources", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_network_acl_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "NetworkAclId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "NetworkAclEntryName", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "resources" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::NetworkAclAssociation", + "Terraform": "alicloud_vpc_network_acl_attachment" + }, + "MainResourceType": { + "ResourceType": "ROS/ALIYUN::VPC::NetworkAcl", + "RefProperty": "ROS/NetworkAclId" + }, + "ProductCode": "vpc", + "Name": { + "zh": "网络ACL关联", + "en": "Associate Network ACL" + }, + "Properties": [ + { + "ROS": "NetworkAclId", + "Terraform": "network_acl_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::NetworkAcl" + } + ] + }, + { + "ROS": "Resources.0.ResourceId", + "Terraform": "resource_id", + "Required": false + }, + { + "ROS": "Resources.0.ResourceType", + "Terraform": "resource_type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "NetworkAclId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::PeeringRouterInterfaceBinding", + "Terraform": null + }, + "ProductCode": "vpc", + "Name": { + "zh": "绑定互联路由器接口", + "en": "Bind Router Interfaces" + }, + "Properties": [ + { + "ROS": "OppositeInterfaceId", + "Terraform": null, + "Required": true + }, + { + "ROS": "OppositeInterfaceOwnerId", + "Terraform": null, + "Required": false + }, + { + "ROS": "OppositeRouterId", + "Terraform": null, + "Required": false + }, + { + "ROS": "RouterInterfaceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::RouterInterface" + } + ] + } + ], + "Attributes": [ + { + "ROS": "RouterInterfaceId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::PeeringRouterInterfaceConnection", + "Terraform": null + }, + "ProductCode": "vpc", + "Name": { + "zh": "互联路由器接口连接", + "en": "Connect Router Interfaces" + }, + "Properties": [ + { + "ROS": "OppositeInterfaceId", + "Terraform": null, + "Required": true + }, + { + "ROS": "RouterInterfaceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::RouterInterface" + } + ] + } + ], + "Attributes": [ + { + "ROS": "OppositeInterfaceId", + "Terraform": null + }, + { + "ROS": "RouterInterfaceId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::PrefixList", + "Terraform": "alicloud_vpc_prefix_list" + }, + "ProductCode": "vpc", + "Name": { + "zh": "VPC前缀列表", + "en": "VPC Prefix List" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "cidr", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": "Entries", + "Terraform": "entrys", + "Required": false, + "Properties": [ + { + "ROS": "Cidr", + "Terraform": "cidr", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + } + ] + }, + { + "ROS": "IpVersion", + "Terraform": "ip_version", + "Required": false + }, + { + "ROS": "MaxEntries", + "Terraform": "max_entries", + "Required": false + }, + { + "ROS": "PrefixListDescription", + "Terraform": "prefix_list_description", + "Required": false + }, + { + "ROS": "PrefixListName", + "Terraform": "prefix_list_name", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "CreateTime", + "Terraform": "create_time" + }, + { + "ROS": "Entries", + "Terraform": null + }, + { + "ROS": "PrefixListId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "IpVersion", + "Terraform": null + }, + { + "ROS": "MaxEntries", + "Terraform": null + }, + { + "ROS": "OwnerId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "prefix_list_association" + }, + { + "ROS": "PrefixListDescription", + "Terraform": null + }, + { + "ROS": "PrefixListId", + "Terraform": "prefix_list_id" + }, + { + "ROS": "PrefixListName", + "Terraform": null + }, + { + "ROS": "ResourceGroupId", + "Terraform": null + }, + { + "ROS": "ShareType", + "Terraform": "share_type" + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "Tags", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::RouteTable", + "Terraform": "alicloud_route_table" + }, + "ProductCode": "vpc", + "Name": { + "zh": "VPC路由表", + "en": "VPC Route Table" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "associate_type", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "RouteTableName", + "Terraform": "route_table_name", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "RouteTableId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "resource_group_id" + }, + { + "ROS": "RouteTableName", + "Terraform": null + }, + { + "ROS": "RouteTableType", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "VpcId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchIds", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::RouteTableAssociation", + "Terraform": "alicloud_route_table_attachment" + }, + "MainResourceType": { + "ResourceType": "ROS/ALIYUN::VPC::RouteTable", + "RefProperty": "ROS/RouteTableId" + }, + "ProductCode": "vpc", + "Name": { + "zh": "VPC路由表关联", + "en": "Associate VPC Route Table" + }, + "Properties": [ + { + "ROS": "RouteTableId", + "Terraform": "route_table_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::RouteTable" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "RouteTableId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::RouterInterface", + "Terraform": "alicloud_express_connect_router_interface" + }, + "ProductCode": "vpc", + "Name": { + "zh": "VPC路由器接口", + "en": "VPC Router Interface" + }, + "Properties": [ + { + "ROS": "AccessPointId", + "Terraform": "access_point_id", + "Required": false + }, + { + "ROS": "AutoPay", + "Terraform": "auto_pay", + "Required": false + }, + { + "ROS": null, + "Terraform": "delete_health_check_ip", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "hc_rate", + "Required": false + }, + { + "ROS": null, + "Terraform": "hc_threshold", + "Required": false + }, + { + "ROS": "HealthCheckSourceIp", + "Terraform": "health_check_source_ip", + "Required": false + }, + { + "ROS": "HealthCheckTargetIp", + "Terraform": "health_check_target_ip", + "Required": false + }, + { + "ROS": "InstanceChargeType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": false + }, + { + "ROS": "OppositeAccessPointId", + "Terraform": "opposite_access_point_id", + "Required": false + }, + { + "ROS": "OppositeInterfaceId", + "Terraform": "opposite_interface_id", + "Required": false + }, + { + "ROS": "OppositeInterfaceOwnerId", + "Terraform": "opposite_interface_owner_id", + "Required": false + }, + { + "ROS": "OppositeRegionId", + "Terraform": "opposite_region_id", + "Required": false + }, + { + "ROS": "OppositeRouterId", + "Terraform": "opposite_router_id", + "Required": false + }, + { + "ROS": "OppositeRouterType", + "Terraform": "opposite_router_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": "Period", + "Terraform": "period", + "Required": false + }, + { + "ROS": "PricingCycle", + "Terraform": "pricing_cycle", + "Required": false + }, + { + "ROS": "Role", + "Terraform": "role", + "Required": true + }, + { + "ROS": "RouterId", + "Terraform": "router_id", + "Required": true + }, + { + "ROS": null, + "Terraform": "router_interface_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "router_interface_name", + "Required": false + }, + { + "ROS": "RouterType", + "Terraform": "router_type", + "Required": false + }, + { + "ROS": "Spec", + "Terraform": "spec", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "bandwidth" + }, + { + "ROS": null, + "Terraform": "business_status" + }, + { + "ROS": null, + "Terraform": "connected_time" + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "cross_border" + }, + { + "ROS": null, + "Terraform": "end_time" + }, + { + "ROS": null, + "Terraform": "has_reservation_data" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "opposite_bandwidth" + }, + { + "ROS": null, + "Terraform": "opposite_interface_business_status" + }, + { + "ROS": null, + "Terraform": "opposite_interface_spec" + }, + { + "ROS": null, + "Terraform": "opposite_interface_status" + }, + { + "ROS": null, + "Terraform": "opposite_vpc_instance_id" + }, + { + "ROS": null, + "Terraform": "reservation_active_time" + }, + { + "ROS": null, + "Terraform": "reservation_bandwidth" + }, + { + "ROS": null, + "Terraform": "reservation_internet_charge_type" + }, + { + "ROS": null, + "Terraform": "reservation_order_type" + }, + { + "ROS": "RouterInterfaceId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "vpc_instance_id" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::SslVpnClientCert", + "Terraform": "alicloud_ssl_vpn_client_cert" + }, + "ProductCode": "vpc", + "Name": { + "zh": "SSL-VPN客户端证书", + "en": "SSL-VPN Client Certificate" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "ca_cert", + "Required": false + }, + { + "ROS": null, + "Terraform": "client_cert", + "Required": false + }, + { + "ROS": null, + "Terraform": "client_config", + "Required": false + }, + { + "ROS": null, + "Terraform": "client_key", + "Required": false + }, + { + "ROS": "Name", + "Terraform": "name", + "Required": false + }, + { + "ROS": "SslVpnServerId", + "Terraform": "ssl_vpn_server_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::SslVpnServer" + } + ] + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "SslVpnClientCertId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::SslVpnServer", + "Terraform": "alicloud_ssl_vpn_server" + }, + "ProductCode": "vpc", + "Name": { + "zh": "SSL-VPN服务端", + "en": "SSL-VPN Server" + }, + "Properties": [ + { + "ROS": "Cipher", + "Terraform": "cipher", + "Required": false + }, + { + "ROS": "ClientIpPool", + "Terraform": "client_ip_pool", + "Required": true + }, + { + "ROS": "Compress", + "Terraform": "compress", + "Required": false + }, + { + "ROS": "EnableMultiFactorAuth", + "Terraform": null, + "Required": false + }, + { + "ROS": "IDaaSApplicationId", + "Terraform": null, + "Required": false + }, + { + "ROS": "IDaaSInstanceId", + "Terraform": null, + "Required": false + }, + { + "ROS": "IDaaSRegionId", + "Terraform": null, + "Required": false + }, + { + "ROS": "LocalSubnet", + "Terraform": "local_subnet", + "Required": true + }, + { + "ROS": "Name", + "Terraform": "name", + "Required": false + }, + { + "ROS": "Port", + "Terraform": "port", + "Required": false + }, + { + "ROS": "Proto", + "Terraform": "protocol", + "Required": false + }, + { + "ROS": "VpnGatewayId", + "Terraform": "vpn_gateway_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::VpnGateway" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "connections" + }, + { + "ROS": "SslVpnServerId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "internet_ip" + }, + { + "ROS": null, + "Terraform": "max_connections" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::TrafficMirrorFilter", + "Terraform": "alicloud_vpc_traffic_mirror_filter" + }, + "ProductCode": "vpc", + "Name": { + "zh": "流量镜像筛选条件", + "en": "Traffic Mirroring Filter" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "action", + "Required": false + }, + { + "ROS": null, + "Terraform": "destination_cidr_block", + "Required": false + }, + { + "ROS": null, + "Terraform": "destination_port_range", + "Required": false + }, + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": "EgressRules", + "Terraform": "egress_rules", + "Required": false, + "Properties": [ + { + "ROS": "Action", + "Terraform": "action", + "Required": true + }, + { + "ROS": "DestinationCidrBlock", + "Terraform": "destination_cidr_block", + "Required": false + }, + { + "ROS": "DestinationPortRange", + "Terraform": "destination_port_range", + "Required": false + }, + { + "ROS": "Priority", + "Terraform": "priority", + "Required": false + }, + { + "ROS": "Protocol", + "Terraform": "protocol", + "Required": true + }, + { + "ROS": "SourceCidrBlock", + "Terraform": "source_cidr_block", + "Required": false + }, + { + "ROS": "SourcePortRange", + "Terraform": "source_port_range", + "Required": false + }, + { + "ROS": null, + "Terraform": "traffic_mirror_filter_rule_status", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "IngressRules", + "Terraform": "ingress_rules", + "Required": false, + "Properties": [ + { + "ROS": "Action", + "Terraform": "action", + "Required": true + }, + { + "ROS": "DestinationCidrBlock", + "Terraform": "destination_cidr_block", + "Required": false + }, + { + "ROS": "DestinationPortRange", + "Terraform": "destination_port_range", + "Required": false + }, + { + "ROS": "Priority", + "Terraform": "priority", + "Required": false + }, + { + "ROS": "Protocol", + "Terraform": "protocol", + "Required": true + }, + { + "ROS": "SourceCidrBlock", + "Terraform": "source_cidr_block", + "Required": false + }, + { + "ROS": "SourcePortRange", + "Terraform": "source_port_range", + "Required": false + }, + { + "ROS": null, + "Terraform": "traffic_mirror_filter_rule_status", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": null, + "Terraform": "priority", + "Required": false + }, + { + "ROS": null, + "Terraform": "protocol", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "source_cidr_block", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_port_range", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": "TrafficMirrorFilterDescription", + "Terraform": "traffic_mirror_filter_description", + "Required": false + }, + { + "ROS": "TrafficMirrorFilterName", + "Terraform": "traffic_mirror_filter_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "EgressRules", + "Terraform": null + }, + { + "ROS": "TrafficMirrorFilterId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "IngressRules", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "TrafficMirrorFilterDescription", + "Terraform": null + }, + { + "ROS": "TrafficMirrorFilterName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::TrafficMirrorSession", + "Terraform": "alicloud_vpc_traffic_mirror_session" + }, + "ProductCode": "vpc", + "Name": { + "zh": "镜像会话", + "en": "Traffic Mirror Session" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": "Enabled", + "Terraform": "enabled", + "Required": false + }, + { + "ROS": "PacketLength", + "Terraform": "packet_length", + "Required": false + }, + { + "ROS": "Priority", + "Terraform": "priority", + "Required": true + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "Tag", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "TrafficMirrorFilterId", + "Terraform": "traffic_mirror_filter_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::TrafficMirrorFilter" + } + ] + }, + { + "ROS": "TrafficMirrorSessionDescription", + "Terraform": "traffic_mirror_session_description", + "Required": false + }, + { + "ROS": "TrafficMirrorSessionName", + "Terraform": "traffic_mirror_session_name", + "Required": false + }, + { + "ROS": "TrafficMirrorSourceIds", + "Terraform": "traffic_mirror_source_ids", + "Required": true + }, + { + "ROS": "TrafficMirrorTargetId", + "Terraform": "traffic_mirror_target_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::SLB::LoadBalancer" + }, + { + "ResourceType": "ROS/ALIYUN::ECS::NetworkInterface" + } + ] + }, + { + "ROS": "TrafficMirrorTargetType", + "Terraform": "traffic_mirror_target_type", + "Required": true + }, + { + "ROS": "VirtualNetworkId", + "Terraform": "virtual_network_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "TrafficMirrorSessionId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::TrafficMirrorSessionSourcesAddition", + "Terraform": null + }, + "MainResourceType": { + "ResourceType": "ROS/ALIYUN::VPC::TrafficMirrorSession", + "RefProperty": "ROS/TrafficMirrorSessionId" + }, + "ProductCode": "vpc", + "Name": { + "zh": "镜像会话镜像源", + "en": "Traffic Mirror Session Source" + }, + "Properties": [ + { + "ROS": "TrafficMirrorSessionId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::TrafficMirrorSession" + } + ] + }, + { + "ROS": "TrafficMirrorSourceIds", + "Terraform": null, + "Required": true, + "Properties": {}, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::NetworkInterface" + } + ], + "Type": "list" + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::VSwitchCidrReservation", + "Terraform": "alicloud_vpc_vswitch_cidr_reservation" + }, + "ProductCode": "vpc", + "Name": { + "zh": "VPC交换机预留网段", + "en": "VPC Reserved vSwitch CIDR" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "cidr_reservation_cidr", + "Required": false + }, + { + "ROS": null, + "Terraform": "cidr_reservation_description", + "Required": false + }, + { + "ROS": null, + "Terraform": "cidr_reservation_mask", + "Required": false + }, + { + "ROS": null, + "Terraform": "cidr_reservation_type", + "Required": false + }, + { + "ROS": "IpVersion", + "Terraform": "ip_version", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": false + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "VSwitchCidrReservationCidr", + "Terraform": null, + "Required": false + }, + { + "ROS": "VSwitchCidrReservationDescription", + "Terraform": null, + "Required": false + }, + { + "ROS": "VSwitchCidrReservationMask", + "Terraform": null, + "Required": false + }, + { + "ROS": "VSwitchCidrReservationName", + "Terraform": "vswitch_cidr_reservation_name", + "Required": false + }, + { + "ROS": "VSwitchCidrReservationType", + "Terraform": null, + "Required": false + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "VSwitchCidrReservationId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": null, + "Terraform": "vpc_id", + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": null, + "Terraform": "vswitch_cidr_reservation_id" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::VirtualBorderRouter", + "Terraform": "alicloud_express_connect_virtual_border_router" + }, + "ProductCode": "vpc", + "Name": { + "zh": "边界路由器", + "en": "VBR" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "associated_physical_connections", + "Required": false + }, + { + "ROS": null, + "Terraform": "bandwidth", + "Required": false + }, + { + "ROS": "CircuitCode", + "Terraform": "circuit_code", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "detect_multiplier", + "Required": false + }, + { + "ROS": null, + "Terraform": "enable_ipv6", + "Required": false + }, + { + "ROS": null, + "Terraform": "include_cross_account_vbr", + "Required": false + }, + { + "ROS": "LocalGatewayIp", + "Terraform": "local_gateway_ip", + "Required": true + }, + { + "ROS": null, + "Terraform": "local_ipv6_gateway_ip", + "Required": false + }, + { + "ROS": null, + "Terraform": "min_rx_interval", + "Required": false + }, + { + "ROS": null, + "Terraform": "min_tx_interval", + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": false + }, + { + "ROS": "PeerGatewayIp", + "Terraform": "peer_gateway_ip", + "Required": true + }, + { + "ROS": null, + "Terraform": "peering_ipv6_subnet_mask", + "Required": false + }, + { + "ROS": "PeeringSubnetMask", + "Terraform": "peering_subnet_mask", + "Required": true + }, + { + "ROS": null, + "Terraform": "peer_ipv6_gateway_ip", + "Required": false + }, + { + "ROS": "PhysicalConnectionId", + "Terraform": "physical_connection_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "Terraform/alicloud_express_connect_physical_connection" + } + ] + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": null, + "Terraform": "vbr_owner_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "virtual_border_router_name", + "Required": false + }, + { + "ROS": "VlanId", + "Terraform": "vlan_id", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "VbrId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "Name", + "Terraform": null + }, + { + "ROS": "RouteTableId", + "Terraform": "route_table_id" + }, + { + "ROS": "VlanInterfaceId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::VpcCidrBlockAssociation", + "Terraform": null + }, + "ProductCode": "vpc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "IpamPoolId", + "Terraform": null, + "Required": false + }, + { + "ROS": "IPv6CidrBlock", + "Terraform": null, + "Required": false + }, + { + "ROS": "Ipv6Isp", + "Terraform": null, + "Required": false + }, + { + "ROS": "IpVersion", + "Terraform": null, + "Required": false + }, + { + "ROS": "SecondaryCidrBlock", + "Terraform": null, + "Required": false + }, + { + "ROS": "SecondaryCidrMask", + "Terraform": null, + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ], + "Attributes": [ + { + "ROS": "VpcId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::VpcIpv6CidrAllocation", + "Terraform": null + }, + "ProductCode": "vpc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "AddressPoolType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Ipv6CidrBlock", + "Terraform": null, + "Required": false + }, + { + "ROS": "Ipv6Isp", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Ipv6CidrBlock", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::VpcPeerConnection", + "Terraform": "alicloud_vpc_peer_connection" + }, + "ProductCode": "vpc", + "Name": { + "zh": "VPC对等连接", + "en": "VPC Peering Connection" + }, + "Properties": [ + { + "ROS": "AcceptingAliUid", + "Terraform": "accepting_ali_uid", + "Required": false + }, + { + "ROS": "AcceptingRegionId", + "Terraform": "accepting_region_id", + "Required": false + }, + { + "ROS": "AcceptingVpcId", + "Terraform": "accepting_vpc_id", + "Required": true + }, + { + "ROS": null, + "Terraform": "bandwidth", + "Required": false + }, + { + "ROS": "DeletionForce", + "Terraform": null, + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": null, + "Terraform": "force_delete", + "Required": false + }, + { + "ROS": "Name", + "Terraform": "peer_connection_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "InstanceId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_express_connect_ec_failover_test_job" + }, + "ProductCode": "vpc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "ec_failover_test_job_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "job_duration", + "Required": false + }, + { + "ROS": null, + "Terraform": "job_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_vpc_gateway_endpoint" + }, + "ProductCode": "vpc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "gateway_endpoint_descrption", + "Required": false + }, + { + "ROS": null, + "Terraform": "gateway_endpoint_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "policy_document", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "service_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": null, + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_vpc_gateway_endpoint_route_table_attachment" + }, + "ProductCode": "vpc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "gateway_endpoint_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "route_table_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_vpc_gateway_route_table_attachment" + }, + "ProductCode": "vpc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": null, + "Terraform": "ipv4_gateway_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "route_table_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_vpc_ipv4_cidr_block" + }, + "ProductCode": "vpc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "secondary_cidr_block", + "Required": false + }, + { + "ROS": null, + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_vpc_ipv6_address" + }, + "ProductCode": "vpc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "ipv6_address_description", + "Required": false + }, + { + "ROS": null, + "Terraform": "ipv6_address_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": null, + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "ipv6_address" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_vpc_ipv6_egress_rule" + }, + "ProductCode": "vpc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "ipv6_egress_rule_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "ipv6_gateway_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::Ipv6Gateway" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "ipv6_egress_rule_id" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_vpc_peer_connection_accepter" + }, + "ProductCode": "vpc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "bandwidth", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": null, + "Terraform": "force_delete", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "peer_connection_accepter_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "accepting_owner_uid" + }, + { + "ROS": null, + "Terraform": "accepting_region_id" + }, + { + "ROS": null, + "Terraform": "accepting_vpc_id" + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": null, + "Terraform": "vpc_id", + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_express_connect_physical_connection" + }, + "ProductCode": "vpc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "access_point_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "bandwidth", + "Required": false + }, + { + "ROS": null, + "Terraform": "circuit_code", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "line_operator", + "Required": false + }, + { + "ROS": null, + "Terraform": "peer_location", + "Required": false + }, + { + "ROS": null, + "Terraform": "period", + "Required": false + }, + { + "ROS": null, + "Terraform": "physical_connection_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "port_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "pricing_cycle", + "Required": false + }, + { + "ROS": null, + "Terraform": "redundant_physical_connection_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": null, + "Terraform": "type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "order_id" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_vpc_public_ip_address_pool" + }, + "ProductCode": "vpc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "biz_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "isp", + "Required": false + }, + { + "ROS": null, + "Terraform": "public_ip_address_pool_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "security_protection_types", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "ip_address_remaining" + }, + { + "ROS": null, + "Terraform": "public_ip_address_pool_id" + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": null, + "Terraform": "total_ip_num" + }, + { + "ROS": null, + "Terraform": "used_ip_num" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_vpc_public_ip_address_pool_cidr_block" + }, + "ProductCode": "vpc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "cidr_block", + "Required": false + }, + { + "ROS": null, + "Terraform": "cidr_mask", + "Required": false + }, + { + "ROS": null, + "Terraform": "public_ip_address_pool_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_express_connect_router_express_connect_router" + }, + "ProductCode": "vpc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "alibaba_side_asn", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "ecr_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "regions", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_express_connect_router_tr_association" + }, + "ProductCode": "vpc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "allowed_prefixes", + "Required": false + }, + { + "ROS": null, + "Terraform": "association_region_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "cen_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "ecr_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "transit_router_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::TransitRouter" + } + ] + }, + { + "ROS": null, + "Terraform": "transit_router_owner_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "association_id" + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_express_connect_router_vbr_child_instance" + }, + "ProductCode": "vpc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "child_instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "child_instance_owner_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "child_instance_region_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "child_instance_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "ecr_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_express_connect_router_vpc_association" + }, + "ProductCode": "vpc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "allowed_prefixes", + "Required": false + }, + { + "ROS": null, + "Terraform": "association_region_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "ecr_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": null, + "Terraform": "vpc_owner_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "association_id" + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_vpc_traffic_mirror_filter_egress_rule" + }, + "ProductCode": "vpc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "action", + "Required": false + }, + { + "ROS": null, + "Terraform": "destination_cidr_block", + "Required": false + }, + { + "ROS": null, + "Terraform": "destination_port_range", + "Required": false + }, + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": null, + "Terraform": "priority", + "Required": false + }, + { + "ROS": null, + "Terraform": "protocol", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_cidr_block", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_port_range", + "Required": false + }, + { + "ROS": null, + "Terraform": "traffic_mirror_filter_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::TrafficMirrorFilter" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": null, + "Terraform": "traffic_mirror_filter_egress_rule_id" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_vpc_traffic_mirror_filter_ingress_rule" + }, + "ProductCode": "vpc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "action", + "Required": false + }, + { + "ROS": null, + "Terraform": "destination_cidr_block", + "Required": false + }, + { + "ROS": null, + "Terraform": "destination_port_range", + "Required": false + }, + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": null, + "Terraform": "priority", + "Required": false + }, + { + "ROS": null, + "Terraform": "protocol", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_cidr_block", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_port_range", + "Required": false + }, + { + "ROS": null, + "Terraform": "traffic_mirror_filter_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::TrafficMirrorFilter" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": null, + "Terraform": "traffic_mirror_filter_ingress_rule_id" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_express_connect_traffic_qos" + }, + "ProductCode": "vpc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "qos_description", + "Required": false + }, + { + "ROS": null, + "Terraform": "qos_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_express_connect_traffic_qos_association" + }, + "ProductCode": "vpc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "qos_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::SAG::Qos" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_express_connect_traffic_qos_queue" + }, + "ProductCode": "vpc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "bandwidth_percent", + "Required": false + }, + { + "ROS": null, + "Terraform": "qos_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::SAG::Qos" + } + ] + }, + { + "ROS": null, + "Terraform": "queue_description", + "Required": false + }, + { + "ROS": null, + "Terraform": "queue_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "queue_type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "queue_id" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_express_connect_traffic_qos_rule" + }, + "ProductCode": "vpc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "dst_cidr", + "Required": false + }, + { + "ROS": null, + "Terraform": "dst_ipv6_cidr", + "Required": false + }, + { + "ROS": null, + "Terraform": "dst_port_range", + "Required": false + }, + { + "ROS": null, + "Terraform": "match_dscp", + "Required": false + }, + { + "ROS": null, + "Terraform": "priority", + "Required": false + }, + { + "ROS": null, + "Terraform": "protocol", + "Required": false + }, + { + "ROS": null, + "Terraform": "qos_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::SAG::Qos" + } + ] + }, + { + "ROS": null, + "Terraform": "queue_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "remarking_dscp", + "Required": false + }, + { + "ROS": null, + "Terraform": "rule_description", + "Required": false + }, + { + "ROS": null, + "Terraform": "rule_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "src_cidr", + "Required": false + }, + { + "ROS": null, + "Terraform": "src_ipv6_cidr", + "Required": false + }, + { + "ROS": null, + "Terraform": "src_port_range", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "rule_id" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_vpc_vbr_ha" + }, + "ProductCode": "vpc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": null, + "Terraform": "peer_vbr_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "vbr_ha_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "vbr_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::VirtualBorderRouter" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_express_connect_vbr_pconn_association" + }, + "ProductCode": "vpc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "enable_ipv6", + "Required": false + }, + { + "ROS": null, + "Terraform": "local_gateway_ip", + "Required": false + }, + { + "ROS": null, + "Terraform": "local_ipv6_gateway_ip", + "Required": false + }, + { + "ROS": null, + "Terraform": "peer_gateway_ip", + "Required": false + }, + { + "ROS": null, + "Terraform": "peering_ipv6_subnet_mask", + "Required": false + }, + { + "ROS": null, + "Terraform": "peering_subnet_mask", + "Required": false + }, + { + "ROS": null, + "Terraform": "peer_ipv6_gateway_ip", + "Required": false + }, + { + "ROS": null, + "Terraform": "physical_connection_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "vbr_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::VirtualBorderRouter" + } + ] + }, + { + "ROS": null, + "Terraform": "vlan_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "circuit_code" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_vpn_gateway_vco_route" + }, + "ProductCode": "vpc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "next_hop", + "Required": false + }, + { + "ROS": null, + "Terraform": "route_dest", + "Required": false + }, + { + "ROS": null, + "Terraform": "vpn_connection_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "weight", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_express_connect_virtual_physical_connection" + }, + "ProductCode": "vpc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": null, + "Terraform": "expect_spec", + "Required": false + }, + { + "ROS": null, + "Terraform": "order_mode", + "Required": false + }, + { + "ROS": null, + "Terraform": "parent_physical_connection_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "spec", + "Required": false + }, + { + "ROS": null, + "Terraform": "virtual_physical_connection_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "vlan_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "vpconn_ali_uid", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "access_point_id" + }, + { + "ROS": null, + "Terraform": "ad_location" + }, + { + "ROS": null, + "Terraform": "bandwidth" + }, + { + "ROS": null, + "Terraform": "business_status" + }, + { + "ROS": null, + "Terraform": "circuit_code" + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "enabled_time" + }, + { + "ROS": null, + "Terraform": "end_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "line_operator" + }, + { + "ROS": null, + "Terraform": "loa_status" + }, + { + "ROS": null, + "Terraform": "parent_physical_connection_ali_uid" + }, + { + "ROS": null, + "Terraform": "peer_location" + }, + { + "ROS": null, + "Terraform": "port_number" + }, + { + "ROS": null, + "Terraform": "port_type" + }, + { + "ROS": null, + "Terraform": "redundant_physical_connection_id" + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": null, + "Terraform": "virtual_physical_connection_status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::AnycastEIP", + "Terraform": "alicloud_eipanycast_anycast_eip_address" + }, + "ProductCode": "eip", + "Name": { + "zh": "任播弹性公网IP", + "en": "Anycast EIP" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "anycast_eip_address_name", + "Required": false + }, + { + "ROS": "Bandwidth", + "Terraform": "bandwidth", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "InternetChargeType", + "Terraform": "internet_charge_type", + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceChargeType", + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "ServiceLocation", + "Terraform": "service_location", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "AnycastId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "IpAddress", + "Terraform": null + }, + { + "ROS": "Name", + "Terraform": null + }, + { + "ROS": "OrderId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::AnycastEIPAssociation", + "Terraform": "alicloud_eipanycast_anycast_eip_address_attachment" + }, + "MainResourceType": { + "ResourceType": "ROS/ALIYUN::VPC::AnycastEIP", + "RefProperty": "ROS/AnycastId" + }, + "ProductCode": "eip", + "Name": { + "zh": "绑定任播弹性公网IP", + "en": "Associate Anycast EIP" + }, + "Properties": [ + { + "ROS": "AnycastId", + "Terraform": "anycast_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::AnycastEIP" + } + ] + }, + { + "ROS": null, + "Terraform": "association_mode", + "Required": false + }, + { + "ROS": "BindInstanceId", + "Terraform": "bind_instance_id", + "Required": true + }, + { + "ROS": "BindInstanceRegionId", + "Terraform": "bind_instance_region_id", + "Required": true + }, + { + "ROS": "BindInstanceType", + "Terraform": "bind_instance_type", + "Required": true + }, + { + "ROS": null, + "Terraform": "pop_locations", + "Required": false + }, + { + "ROS": null, + "Terraform": "private_ip_address", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "AnycastId", + "Terraform": null + }, + { + "ROS": "BindInstanceId", + "Terraform": null + }, + { + "ROS": "BindInstanceRegionId", + "Terraform": null + }, + { + "ROS": "BindInstanceType", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "bind_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::EIP", + "Terraform": "alicloud_eip_address" + }, + "ProductCode": "eip", + "Name": { + "zh": "弹性公网IP", + "en": "EIP" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "activity_id", + "Required": false + }, + { + "ROS": "Name", + "Terraform": "address_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "allocation_id", + "Required": false + }, + { + "ROS": "AutoPay", + "Terraform": "auto_pay", + "Required": false + }, + { + "ROS": "Bandwidth", + "Terraform": "bandwidth", + "Required": false + }, + { + "ROS": "DeletionProtection", + "Terraform": "deletion_protection", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "high_definition_monitor_log_status", + "Required": false + }, + { + "ROS": "InternetChargeType", + "Terraform": "internet_charge_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "ip_address", + "Required": false + }, + { + "ROS": "Isp", + "Terraform": "isp", + "Required": false + }, + { + "ROS": null, + "Terraform": "log_project", + "Required": false + }, + { + "ROS": null, + "Terraform": "log_store", + "Required": false + }, + { + "ROS": null, + "Terraform": "mode", + "Required": false + }, + { + "ROS": "Netmode", + "Terraform": "netmode", + "Required": false + }, + { + "ROS": "InstanceChargeType", + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": "Period", + "Terraform": "period", + "Required": false + }, + { + "ROS": "PricingCycle", + "Terraform": "pricing_cycle", + "Required": false + }, + { + "ROS": "PublicIpAddressPoolId", + "Terraform": "public_ip_address_pool_id", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "SecurityProtectionTypes", + "Terraform": "security_protection_types", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "Zone", + "Terraform": "zone", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "EipAddress", + "Terraform": null + }, + { + "ROS": "AllocationId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "Isp", + "Terraform": null + }, + { + "ROS": "OrderId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::EIPAssociation", + "Terraform": "alicloud_eip_association" + }, + "MainResourceType": { + "ResourceType": "ROS/ALIYUN::VPC::EIP", + "RefProperty": "ROS/AllocationId" + }, + "ProductCode": "eip", + "Name": { + "zh": "弹性公网IP关联", + "en": "Associate EIP" + }, + "Properties": [ + { + "ROS": "AllocationId", + "Terraform": "allocation_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::EIP" + } + ] + }, + { + "ROS": null, + "Terraform": "force", + "Required": false + }, + { + "ROS": "InstanceId", + "Terraform": "instance_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Instance" + }, + { + "ResourceType": "ROS/ALIYUN::SLB::LoadBalancer" + }, + { + "ResourceType": "ROS/ALIYUN::VPC::HaVip" + }, + { + "ResourceType": "ROS/ALIYUN::ECS::InstanceGroup", + "SyncWith": "ROS/InstanceIds" + }, + { + "ResourceType": "ROS/ALIYUN::ECS::InstanceGroupClone", + "SyncWith": "ROS/InstanceIds" + } + ] + }, + { + "ROS": null, + "Terraform": "instance_type", + "Required": false + }, + { + "ROS": "Mode", + "Terraform": "mode", + "Required": false + }, + { + "ROS": "PrivateIpAddress", + "Terraform": "private_ip_address", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::NetworkInterface", + "SyncWith": "ROS/PrivateIpAddress" + } + ] + }, + { + "ROS": null, + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ], + "Attributes": [ + { + "ROS": "AllocationId", + "Terraform": null + }, + { + "ROS": "EipAddress", + "Terraform": null + }, + { + "ROS": "AllocationId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::EIPPro", + "Terraform": null + }, + "ProductCode": "eip", + "Name": { + "zh": "弹性公网IP Pro", + "en": "EIP Pro" + }, + "Properties": [ + { + "ROS": "AutoPay", + "Terraform": null, + "Required": false + }, + { + "ROS": "Bandwidth", + "Terraform": null, + "Required": false + }, + { + "ROS": "DeletionProtection", + "Terraform": null, + "Required": false + }, + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceChargeType", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::EIP" + } + ] + }, + { + "ROS": "InternetChargeType", + "Terraform": null, + "Required": false + }, + { + "ROS": "IpAddress", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::EIP", + "SyncWith": "ROS/EipAddress" + } + ] + }, + { + "ROS": "ISP", + "Terraform": null, + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": false + }, + { + "ROS": "Netmode", + "Terraform": null, + "Required": false + }, + { + "ROS": "Period", + "Terraform": null, + "Required": false + }, + { + "ROS": "PricingCycle", + "Terraform": null, + "Required": false + }, + { + "ROS": "PublicIpAddressPoolId", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "SecurityProtectionTypes", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "AllocationId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "EipAddress", + "Terraform": null + }, + { + "ROS": "ISP", + "Terraform": null + }, + { + "ROS": "OrderId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::EIPSegment", + "Terraform": "alicloud_eip_segment_address" + }, + "ProductCode": "eip", + "Name": { + "zh": "连续弹性公网IP", + "en": "Contiguous EIPs" + }, + "Properties": [ + { + "ROS": "Bandwidth", + "Terraform": "bandwidth", + "Required": false + }, + { + "ROS": "EipMask", + "Terraform": "eip_mask", + "Required": true + }, + { + "ROS": "InternetChargeType", + "Terraform": "internet_charge_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "isp", + "Required": false + }, + { + "ROS": "Netmode", + "Terraform": "netmode", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "zone", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "EipAddresses", + "Terraform": null + }, + { + "ROS": "EipSegmentInstanceId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "segment_address_name" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SLB::AccessControl", + "Terraform": "alicloud_slb_acl" + }, + "ProductCode": "slb", + "Name": { + "zh": "SLB访问控制策略组", + "en": "SLB ACL" + }, + "Properties": [ + { + "ROS": "AclEntries", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Comment", + "Terraform": null, + "Required": false + }, + { + "ROS": "Entry", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "AddressIPVersion", + "Terraform": "ip_version", + "Required": false + }, + { + "ROS": "AclName", + "Terraform": "name", + "Required": true + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": "AclId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SLB::AccessLogsAddition", + "Terraform": null + }, + "ProductCode": "slb", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "LoadBalancerId", + "Terraform": null, + "Required": true + }, + { + "ROS": "LogProject", + "Terraform": null, + "Required": true + }, + { + "ROS": "LogStore", + "Terraform": null, + "Required": true + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SLB::BackendServerAttachment", + "Terraform": "alicloud_slb_backend_server" + }, + "MainResourceType": { + "ResourceType": "ROS/ALIYUN::SLB::LoadBalancer", + "RefProperty": "ROS/LoadBalancerId" + }, + "ProductCode": "slb", + "Name": { + "zh": "添加后端服务器", + "en": "Attach Backend Server" + }, + "Properties": [ + { + "ROS": "BackendServerList", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "BackendServers", + "Terraform": "backend_servers", + "Required": false, + "Properties": [ + { + "ROS": "ServerId", + "Terraform": "server_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Instance" + }, + { + "ResourceType": "ROS/ALIYUN::ECS::InstanceGroup" + } + ] + }, + { + "ROS": "ServerIp", + "Terraform": "server_ip", + "Required": false + }, + { + "ROS": "Type", + "Terraform": "type", + "Required": false + }, + { + "ROS": "Weight", + "Terraform": "weight", + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "BackendServerWeightList", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "delete_protection_validation", + "Required": false + }, + { + "ROS": "LoadBalancerId", + "Terraform": "load_balancer_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::SLB::LoadBalancer" + } + ] + } + ], + "Attributes": [ + { + "ROS": "BackendServers", + "Terraform": null + }, + { + "ROS": "LoadBalancerId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SLB::BackendServerToVServerGroupAddition", + "Terraform": "alicloud_slb_server_group_server_attachment" + }, + "ProductCode": "slb", + "Name": { + "zh": "添加后端服务器", + "en": "Attach Backend Server to Server Group" + }, + "Properties": [ + { + "ROS": "BackendServers.Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "BackendServers.Port", + "Terraform": "port", + "Required": false + }, + { + "ROS": "VServerGroupId", + "Terraform": "server_group_id", + "Required": true + }, + { + "ROS": "BackendServers.ServerId", + "Terraform": "server_id", + "Required": false + }, + { + "ROS": "BackendServers.Type", + "Terraform": "type", + "Required": false + }, + { + "ROS": "BackendServers.Weight", + "Terraform": "weight", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "VServerGroupId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SLB::Certificate", + "Terraform": "alicloud_slb_ca_certificate" + }, + "ProductCode": "slb", + "Name": { + "zh": "SLB证书", + "en": "SLB Certificate" + }, + "Properties": [ + { + "ROS": "AliCloudCertificateId", + "Terraform": "alicloud_certificate_id", + "Required": false + }, + { + "ROS": "AliCloudCertificateName", + "Terraform": "alicloud_certificate_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "alicloud_certificate_region_id", + "Required": false + }, + { + "ROS": "Certificate", + "Terraform": "ca_certificate", + "Required": false + }, + { + "ROS": "CertificateName", + "Terraform": "ca_certificate_name", + "Required": false + }, + { + "ROS": "CertificateType", + "Terraform": null, + "Required": false + }, + { + "ROS": "CertificateName", + "Terraform": "name", + "Required": false + }, + { + "ROS": "PrivateKey", + "Terraform": "private_key", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "Certificate", + "Terraform": "server_certificate", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": "Fingerprint", + "Terraform": null + }, + { + "ROS": "CertificateId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SLB::DomainExtension", + "Terraform": "alicloud_slb_domain_extension" + }, + "ProductCode": "slb", + "Name": { + "zh": "SLB扩展域名", + "en": "SLB Additional Domain" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "delete_protection_validation", + "Required": false + }, + { + "ROS": "Domain", + "Terraform": "domain", + "Required": true + }, + { + "ROS": "ListenerPort", + "Terraform": "frontend_port", + "Required": true + }, + { + "ROS": "LoadBalancerId", + "Terraform": "load_balancer_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::SLB::LoadBalancer" + } + ] + }, + { + "ROS": "ServerCertificateId", + "Terraform": "server_certificate_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::SLB::Certificate" + } + ] + } + ], + "Attributes": [ + { + "ROS": "DomainExtensionId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "ListenerPort", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SLB::Listener", + "Terraform": "alicloud_slb_listener" + }, + "MainResourceType": { + "ResourceType": "ROS/ALIYUN::SLB::LoadBalancer", + "RefProperty": "ROS/LoadBalancerId" + }, + "ProductCode": "slb", + "Name": { + "zh": "SLB监听", + "en": "SLB Listener" + }, + "Properties": [ + { + "ROS": "AclId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::SLB::AccessControl" + } + ] + }, + { + "ROS": "AclIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "AclStatus", + "Terraform": null, + "Required": false + }, + { + "ROS": "AclType", + "Terraform": null, + "Required": false + }, + { + "ROS": "BackendServerPort", + "Terraform": null, + "Required": false + }, + { + "ROS": "Bandwidth", + "Terraform": null, + "Required": true + }, + { + "ROS": "CACertificateId", + "Terraform": null, + "Required": false + }, + { + "ROS": "ConnectionDrain", + "Terraform": null, + "Required": false + }, + { + "ROS": "ConnectionDrainTimeout", + "Terraform": null, + "Required": false + }, + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "EnableHttp2", + "Terraform": null, + "Required": false + }, + { + "ROS": "FullNatEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "Gzip", + "Terraform": null, + "Required": false + }, + { + "ROS": "HealthCheck", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Domain", + "Terraform": null, + "Required": false + }, + { + "ROS": "Exp", + "Terraform": null, + "Required": false + }, + { + "ROS": "HealthCheckMethod", + "Terraform": null, + "Required": false + }, + { + "ROS": "HealthCheckType", + "Terraform": null, + "Required": false + }, + { + "ROS": "HealthyThreshold", + "Terraform": null, + "Required": false + }, + { + "ROS": "HttpCode", + "Terraform": null, + "Required": false + }, + { + "ROS": "Interval", + "Terraform": null, + "Required": false + }, + { + "ROS": "Port", + "Terraform": null, + "Required": false + }, + { + "ROS": "Req", + "Terraform": null, + "Required": false + }, + { + "ROS": "Switch", + "Terraform": null, + "Required": false + }, + { + "ROS": "Timeout", + "Terraform": null, + "Required": false + }, + { + "ROS": "UnhealthyThreshold", + "Terraform": null, + "Required": false + }, + { + "ROS": "URI", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": null, + "Terraform": "HTTP Listener", + "Required": false + }, + { + "ROS": "HttpConfig", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "ForwardPort", + "Terraform": null, + "Required": false + }, + { + "ROS": "ListenerForward", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": null, + "Terraform": "HTTPS Listener", + "Required": false + }, + { + "ROS": "IdleTimeout", + "Terraform": null, + "Required": false + }, + { + "ROS": "ListenerPort", + "Terraform": null, + "Required": true + }, + { + "ROS": "LoadBalancerId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::SLB::LoadBalancer" + } + ] + }, + { + "ROS": "MasterSlaveServerGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::SLB::MasterSlaveServerGroup" + } + ] + }, + { + "ROS": "Persistence", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Cookie", + "Terraform": null, + "Required": false + }, + { + "ROS": "CookieTimeout", + "Terraform": null, + "Required": false + }, + { + "ROS": "PersistenceTimeout", + "Terraform": null, + "Required": false + }, + { + "ROS": "StickySession", + "Terraform": null, + "Required": false + }, + { + "ROS": "StickySessionType", + "Terraform": null, + "Required": false + }, + { + "ROS": "XForwardedFor", + "Terraform": null, + "Required": false + }, + { + "ROS": "XForwardedFor_ClientSrcPort", + "Terraform": null, + "Required": false + }, + { + "ROS": "XForwardedFor_proto", + "Terraform": null, + "Required": false + }, + { + "ROS": "XForwardedFor_SLBID", + "Terraform": null, + "Required": false + }, + { + "ROS": "XForwardedFor_SLBIP", + "Terraform": null, + "Required": false + }, + { + "ROS": "XForwardedFor_SLBPORT", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "PortRange", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "EndPort", + "Terraform": null, + "Required": true + }, + { + "ROS": "StartPort", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "Protocol", + "Terraform": null, + "Required": true + }, + { + "ROS": "ProxyProtocolV2Enabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "RequestTimeout", + "Terraform": null, + "Required": false + }, + { + "ROS": "Scheduler", + "Terraform": null, + "Required": false + }, + { + "ROS": "ServerCertificateId", + "Terraform": null, + "Required": false + }, + { + "ROS": "StartListener", + "Terraform": null, + "Required": false + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": null, + "Terraform": "TCP Listener", + "Required": false + }, + { + "ROS": "TLSCipherPolicy", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "UDP Listener", + "Required": false + }, + { + "ROS": "VServerGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::SLB::VServerGroup" + } + ] + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "ListenerPortsAndProtocol", + "Terraform": null + }, + { + "ROS": "LoadBalancerId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "x_forwarded_for" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SLB::LoadBalancer", + "Terraform": "alicloud_slb" + }, + "ProductCode": "slb", + "Name": { + "zh": "负载均衡SLB", + "en": "SLB Instance" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "address", + "Required": false + }, + { + "ROS": "AddressIPVersion", + "Terraform": "address_ip_version", + "Required": false + }, + { + "ROS": "AddressType", + "Terraform": "address_type", + "Required": false + }, + { + "ROS": "Bandwidth", + "Terraform": "bandwidth", + "Required": false + }, + { + "ROS": "DeletionProtection", + "Terraform": "delete_protection", + "Required": false + }, + { + "ROS": "PayType", + "Terraform": "instance_charge_type", + "Required": false + }, + { + "ROS": "AddressType", + "Terraform": "internet", + "Required": false + }, + { + "ROS": "InternetChargeType", + "Terraform": "internet_charge_type", + "Required": false + }, + { + "ROS": "LoadBalancerName", + "Terraform": "load_balancer_name", + "Required": false + }, + { + "ROS": "LoadBalancerSpec", + "Terraform": "load_balancer_spec", + "Required": false + }, + { + "ROS": "MasterZoneId", + "Terraform": "master_zone_id", + "Required": false + }, + { + "ROS": "ModificationProtectionReason", + "Terraform": "modification_protection_reason", + "Required": false + }, + { + "ROS": "ModificationProtectionStatus", + "Terraform": "modification_protection_status", + "Required": false + }, + { + "ROS": "PayType", + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": "Duration", + "Terraform": "period", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "SlaveZoneId", + "Terraform": "slave_zone_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "address" + }, + { + "ROS": "AddressIPVersion", + "Terraform": null + }, + { + "ROS": "AddressType", + "Terraform": null + }, + { + "ROS": "Bandwidth", + "Terraform": null + }, + { + "ROS": "LoadBalancerId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "IpAddress", + "Terraform": null + }, + { + "ROS": "LoadBalancerName", + "Terraform": null + }, + { + "ROS": "LoadBalancerSpec", + "Terraform": null + }, + { + "ROS": "MasterZoneId", + "Terraform": null + }, + { + "ROS": "NetworkType", + "Terraform": null + }, + { + "ROS": "OrderId", + "Terraform": null + }, + { + "ROS": "PayType", + "Terraform": null + }, + { + "ROS": "ResourceGroupId", + "Terraform": null + }, + { + "ROS": "SlaveZoneId", + "Terraform": null + }, + { + "ROS": "VpcId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SLB::LoadBalancerClone", + "Terraform": null + }, + "ProductCode": "slb", + "Name": { + "zh": "克隆SLB负载均衡实例", + "en": "Clone SLB Instance" + }, + "Properties": [ + { + "ROS": "BackendServers", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "ServerId", + "Terraform": null, + "Required": true + }, + { + "ROS": "ServerIp", + "Terraform": null, + "Required": false + }, + { + "ROS": "Type", + "Terraform": null, + "Required": false + }, + { + "ROS": "Weight", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "BackendServersPolicy", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceChargeType", + "Terraform": null, + "Required": false + }, + { + "ROS": "LoadBalancerName", + "Terraform": null, + "Required": false + }, + { + "ROS": "LoadBalancerSpec", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "SourceLoadBalancerId", + "Terraform": null, + "Required": true + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "TagsPolicy", + "Terraform": null, + "Required": false + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Attributes": [ + { + "ROS": "LoadBalancerId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SLB::MasterSlaveServerGroup", + "Terraform": "alicloud_slb_master_slave_server_group" + }, + "ProductCode": "slb", + "Name": { + "zh": "SLB主备服务器组", + "en": "SLB Primary/Secondary Server Group" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "delete_protection_validation", + "Required": false + }, + { + "ROS": "LoadBalancerId", + "Terraform": "load_balancer_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::SLB::LoadBalancer" + } + ] + }, + { + "ROS": "MasterSlaveServerGroupName", + "Terraform": "name", + "Required": false + }, + { + "ROS": "MasterSlaveBackendServers", + "Terraform": "servers", + "Required": true, + "Properties": [ + { + "ROS": null, + "Terraform": "is_backup", + "Required": false + }, + { + "ROS": "Port", + "Terraform": "port", + "Required": true + }, + { + "ROS": "ServerId", + "Terraform": "server_ids", + "Required": true + }, + { + "ROS": "ServerType", + "Terraform": "server_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "type", + "Required": false + }, + { + "ROS": "Weight", + "Terraform": "weight", + "Required": true + } + ], + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "MasterSlaveServerGroupId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SLB::Rule", + "Terraform": "alicloud_slb_rule" + }, + "ProductCode": "slb", + "Name": { + "zh": "SLB转发规则", + "en": "SLB Forwarding Rule" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "cookie", + "Required": false + }, + { + "ROS": null, + "Terraform": "cookie_timeout", + "Required": false + }, + { + "ROS": null, + "Terraform": "delete_protection_validation", + "Required": false + }, + { + "ROS": "RuleList.0.Domain", + "Terraform": "domain", + "Required": false + }, + { + "ROS": "ListenerPort", + "Terraform": "frontend_port", + "Required": true + }, + { + "ROS": null, + "Terraform": "health_check", + "Required": false + }, + { + "ROS": null, + "Terraform": "health_check_connect_port", + "Required": false + }, + { + "ROS": null, + "Terraform": "health_check_domain", + "Required": false + }, + { + "ROS": null, + "Terraform": "health_check_http_code", + "Required": false + }, + { + "ROS": null, + "Terraform": "health_check_interval", + "Required": false + }, + { + "ROS": null, + "Terraform": "health_check_timeout", + "Required": false + }, + { + "ROS": null, + "Terraform": "health_check_uri", + "Required": false + }, + { + "ROS": null, + "Terraform": "healthy_threshold", + "Required": false + }, + { + "ROS": "ListenerProtocol", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "listener_sync", + "Required": false + }, + { + "ROS": "LoadBalancerId", + "Terraform": "load_balancer_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::SLB::LoadBalancer" + } + ] + }, + { + "ROS": "RuleList.0.RuleName", + "Terraform": "name", + "Required": false + }, + { + "ROS": null, + "Terraform": "scheduler", + "Required": false + }, + { + "ROS": "RuleList.0.VServerGroupId", + "Terraform": "server_group_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "sticky_session", + "Required": false + }, + { + "ROS": null, + "Terraform": "sticky_session_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "unhealthy_threshold", + "Required": false + }, + { + "ROS": "RuleList.0.Url", + "Terraform": "url", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Rules", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "Rules", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SLB::TLSPolicy", + "Terraform": "alicloud_slb_tls_cipher_policy" + }, + "ProductCode": "slb", + "Name": { + "zh": "SLB TLSPolicy", + "en": "SLB TLS Policy" + }, + "Properties": [ + { + "ROS": "Ciphers", + "Terraform": "ciphers", + "Required": true + }, + { + "ROS": null, + "Terraform": "tls_cipher_policy_name", + "Required": false + }, + { + "ROS": "TLSPolicyName", + "Terraform": null, + "Required": true + }, + { + "ROS": "TlsVersions", + "Terraform": "tls_versions", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "Ciphers", + "Terraform": null + }, + { + "ROS": "CreateTime", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "InstanceId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "TLSPolicyName", + "Terraform": null + }, + { + "ROS": "TlsVersions", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SLB::VServerGroup", + "Terraform": "alicloud_slb_server_group" + }, + "ProductCode": "slb", + "Name": { + "zh": "SLB虚拟服务器组", + "en": "SLB vServer Group" + }, + "Properties": [ + { + "ROS": "BackendServers", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "Port", + "Terraform": null, + "Required": true + }, + { + "ROS": "ServerId", + "Terraform": null, + "Required": true + }, + { + "ROS": "ServerIp", + "Terraform": null, + "Required": false + }, + { + "ROS": "Type", + "Terraform": null, + "Required": false + }, + { + "ROS": "Weight", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": null, + "Terraform": "delete_protection_validation", + "Required": false + }, + { + "ROS": "LoadBalancerId", + "Terraform": "load_balancer_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::SLB::LoadBalancer" + } + ] + }, + { + "ROS": "VServerGroupName", + "Terraform": "name", + "Required": true + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": "BackendServers", + "Terraform": null + }, + { + "ROS": "VServerGroupId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "LoadBalancerId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_slb_acl_entry_attachment" + }, + "ProductCode": "slb", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "acl_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "comment", + "Required": false + }, + { + "ROS": null, + "Terraform": "entry", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::OSS::Bucket", + "Terraform": "alicloud_oss_bucket" + }, + "ProductCode": "oss", + "Name": { + "zh": "OSS存储空间", + "en": "OSS Bucket" + }, + "Properties": [ + { + "ROS": "AccessControl", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "access_monitor", + "Required": false + }, + { + "ROS": "BucketName", + "Terraform": "bucket", + "Required": true + }, + { + "ROS": "CORSConfiguration", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "CORSRule", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "AllowedHeader", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "AllowedMethod", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "AllowedOrigin", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "ExposeHeader", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "MaxAgeSeconds", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "ResponseVary", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "CORSRule", + "Terraform": "cors_rule", + "Required": false, + "Properties": [ + { + "ROS": "AllowedHeader", + "Terraform": "allowed_headers", + "Required": false + }, + { + "ROS": "AllowedMethod", + "Terraform": "allowed_methods", + "Required": false + }, + { + "ROS": "AllowedOrigin", + "Terraform": "allowed_origins", + "Required": false + }, + { + "ROS": "ExposeHeader", + "Terraform": "expose_headers", + "Required": false + }, + { + "ROS": "MaxAgeSeconds", + "Terraform": "max_age_seconds", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "EnableOssHdfsService", + "Terraform": null, + "Required": false + }, + { + "ROS": "DeletionForce", + "Terraform": "force_destroy", + "Required": false + }, + { + "ROS": "LifecycleConfiguration", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Rule", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "AbortMultipartUpload", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "CreatedBeforeDate", + "Terraform": null, + "Required": false + }, + { + "ROS": "Days", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "Expiration", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "CreatedBeforeDate", + "Terraform": null, + "Required": false + }, + { + "ROS": "Days", + "Terraform": null, + "Required": false + }, + { + "ROS": "ExpiredObjectDeleteMarker", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "Filter", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Not", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Prefix", + "Terraform": null, + "Required": false + }, + { + "ROS": "Tag", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + } + ] + } + ] + }, + { + "ROS": "ID", + "Terraform": null, + "Required": false + }, + { + "ROS": "Prefix", + "Terraform": null, + "Required": true + }, + { + "ROS": "Status", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + } + ] + }, + { + "ROS": null, + "Terraform": "lifecycle_rule", + "Required": false + }, + { + "ROS": null, + "Terraform": "lifecycle_rule_allow_same_action_overlap", + "Required": false + }, + { + "ROS": "LoggingConfiguration", + "Terraform": "logging", + "Required": false, + "Properties": [ + { + "ROS": "TargetBucket", + "Terraform": "target_bucket", + "Required": false + }, + { + "ROS": "TargetPrefix", + "Terraform": "target_prefix", + "Required": false + } + ] + }, + { + "ROS": "Policy", + "Terraform": null, + "Required": false + }, + { + "ROS": "RedundancyType", + "Terraform": "redundancy_type", + "Required": false + }, + { + "ROS": "RefererConfiguration", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "AllowEmptyReferer", + "Terraform": null, + "Required": false + }, + { + "ROS": "RefererList", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "ServerSideEncryptionConfiguration", + "Terraform": "server_side_encryption_rule", + "Required": false, + "Properties": [ + { + "ROS": "KMSMasterKeyID", + "Terraform": "kms_master_key_id", + "Required": false + }, + { + "ROS": "SSEAlgorithm", + "Terraform": "sse_algorithm", + "Required": true + } + ] + }, + { + "ROS": "StorageClass", + "Terraform": "storage_class", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": null, + "Terraform": "transfer_acceleration", + "Required": false + }, + { + "ROS": null, + "Terraform": "versioning", + "Required": false + }, + { + "ROS": "VersioningConfiguration", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Status", + "Terraform": null, + "Required": true + } + ] + }, + { + "ROS": "WebsiteConfiguration", + "Terraform": "website", + "Required": false, + "Properties": [ + { + "ROS": "ErrorDocument", + "Terraform": "error_document", + "Required": false + }, + { + "ROS": "IndexDocument", + "Terraform": "index_document", + "Required": false + } + ] + }, + { + "ROS": "WebsiteConfigurationV2", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "ErrorDocument", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "HttpStatus", + "Terraform": null, + "Required": false + }, + { + "ROS": "Key", + "Terraform": null, + "Required": true + } + ] + }, + { + "ROS": "IndexDocument", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Suffix", + "Terraform": null, + "Required": true + }, + { + "ROS": "SupportSubDir", + "Terraform": null, + "Required": false + }, + { + "ROS": "Type", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "RoutingRules", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Condition", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "HttpErrorCodeReturnedEquals", + "Terraform": null, + "Required": false + }, + { + "ROS": "IncludeHeaders", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Equals", + "Terraform": null, + "Required": false + }, + { + "ROS": "Key", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "KeyPrefixEquals", + "Terraform": null, + "Required": false + }, + { + "ROS": "KeySuffixEquals", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "Redirect", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "EnableReplacePrefix", + "Terraform": null, + "Required": false + }, + { + "ROS": "HostName", + "Terraform": null, + "Required": false + }, + { + "ROS": "HttpRedirectCode", + "Terraform": null, + "Required": false + }, + { + "ROS": "MirrorCheckMd5", + "Terraform": null, + "Required": false + }, + { + "ROS": "MirrorFollowRedirect", + "Terraform": null, + "Required": false + }, + { + "ROS": "MirrorHeaders", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Pass", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "PassAll", + "Terraform": null, + "Required": false + }, + { + "ROS": "Remove", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "Sets", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + } + ] + }, + { + "ROS": "MirrorPassQueryString", + "Terraform": null, + "Required": false + }, + { + "ROS": "MirrorURL", + "Terraform": null, + "Required": false + }, + { + "ROS": "PassQueryString", + "Terraform": null, + "Required": false + }, + { + "ROS": "Protocol", + "Terraform": null, + "Required": false + }, + { + "ROS": "RedirectType", + "Terraform": null, + "Required": true + }, + { + "ROS": "ReplaceKeyPrefixWith", + "Terraform": null, + "Required": false + }, + { + "ROS": "ReplaceKeyWith", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "RuleNumber", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + } + ] + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "creation_date" + }, + { + "ROS": "DomainName", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "extranet_endpoint" + }, + { + "ROS": "Name", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "InternalDomainName", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "intranet_endpoint" + }, + { + "ROS": null, + "Terraform": "location" + }, + { + "ROS": null, + "Terraform": "owner" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::OSS::Directory", + "Terraform": null + }, + "ProductCode": "oss", + "Name": { + "zh": "OSS目录", + "en": "OSS Directory" + }, + "Properties": [ + { + "ROS": "BucketName", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::OSS::Bucket" + } + ] + }, + { + "ROS": "DeletionForce", + "Terraform": null, + "Required": false + }, + { + "ROS": "DirectoryName", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "BucketName", + "Terraform": null + }, + { + "ROS": "DirectoryName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::OSS::Domain", + "Terraform": null + }, + "ProductCode": "oss", + "Name": { + "zh": "OSS域名", + "en": "OSS Domain" + }, + "Properties": [ + { + "ROS": "BucketName", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::OSS::Bucket" + } + ] + }, + { + "ROS": "DomainName", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::OSS::Bucket", + "SyncWith": "ROS/DomainName" + } + ] + } + ], + "Attributes": [ + { + "ROS": "BucketName", + "Terraform": null + }, + { + "ROS": "DomainName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::OSS::ObjectAcl", + "Terraform": null + }, + "ProductCode": "oss", + "Name": { + "zh": "OSS ObjectAcl", + "en": "OSS Object ACL" + }, + "Properties": [ + { + "ROS": "Bucket", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::OSS::Bucket" + } + ] + }, + { + "ROS": "ObjectAcl", + "Terraform": null, + "Required": true + }, + { + "ROS": "ObjectKey", + "Terraform": null, + "Required": true + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::OSS::Website", + "Terraform": null + }, + "ProductCode": "oss", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "BucketName", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::OSS::Bucket" + } + ] + }, + { + "ROS": "WebsiteConfiguration", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "ErrorDocument", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "HttpStatus", + "Terraform": null, + "Required": false + }, + { + "ROS": "Key", + "Terraform": null, + "Required": true + } + ] + }, + { + "ROS": "IndexDocument", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Suffix", + "Terraform": null, + "Required": true + }, + { + "ROS": "SupportSubDir", + "Terraform": null, + "Required": false + }, + { + "ROS": "Type", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "RoutingRules", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Condition", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "HttpErrorCodeReturnedEquals", + "Terraform": null, + "Required": false + }, + { + "ROS": "IncludeHeaders", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Equals", + "Terraform": null, + "Required": false + }, + { + "ROS": "Key", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "KeyPrefixEquals", + "Terraform": null, + "Required": false + }, + { + "ROS": "KeySuffixEquals", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "Redirect", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "EnableReplacePrefix", + "Terraform": null, + "Required": false + }, + { + "ROS": "HostName", + "Terraform": null, + "Required": false + }, + { + "ROS": "HttpRedirectCode", + "Terraform": null, + "Required": false + }, + { + "ROS": "MirrorCheckMd5", + "Terraform": null, + "Required": false + }, + { + "ROS": "MirrorFollowRedirect", + "Terraform": null, + "Required": false + }, + { + "ROS": "MirrorHeaders", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Pass", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "PassAll", + "Terraform": null, + "Required": false + }, + { + "ROS": "Remove", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "Sets", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + } + ] + }, + { + "ROS": "MirrorPassQueryString", + "Terraform": null, + "Required": false + }, + { + "ROS": "MirrorURL", + "Terraform": null, + "Required": false + }, + { + "ROS": "PassQueryString", + "Terraform": null, + "Required": false + }, + { + "ROS": "Protocol", + "Terraform": null, + "Required": false + }, + { + "ROS": "RedirectType", + "Terraform": null, + "Required": true + }, + { + "ROS": "ReplaceKeyPrefixWith", + "Terraform": null, + "Required": false + }, + { + "ROS": "ReplaceKeyWith", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "RuleNumber", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + } + ] + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_oss_account_public_access_block" + }, + "ProductCode": "oss", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "block_public_access", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_oss_bucket_access_monitor" + }, + "ProductCode": "oss", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "bucket", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_oss_bucket_acl" + }, + "ProductCode": "oss", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "acl", + "Required": false + }, + { + "ROS": null, + "Terraform": "bucket", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_oss_bucket_cors" + }, + "ProductCode": "oss", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "bucket", + "Required": false + }, + { + "ROS": null, + "Terraform": "cors_rule", + "Required": false + }, + { + "ROS": null, + "Terraform": "response_vary", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_oss_bucket_data_redundancy_transition" + }, + "ProductCode": "oss", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "bucket", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": null, + "Terraform": "task_id" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_oss_bucket_https_config" + }, + "ProductCode": "oss", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "bucket", + "Required": false + }, + { + "ROS": null, + "Terraform": "enable", + "Required": false + }, + { + "ROS": null, + "Terraform": "tls_versions", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_oss_bucket_logging" + }, + "ProductCode": "oss", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "bucket", + "Required": false + }, + { + "ROS": null, + "Terraform": "target_bucket", + "Required": false + }, + { + "ROS": null, + "Terraform": "target_prefix", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_oss_bucket_meta_query" + }, + "ProductCode": "oss", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "bucket", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_oss_bucket_object" + }, + "ProductCode": "oss", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "acl", + "Required": false + }, + { + "ROS": null, + "Terraform": "bucket", + "Required": false + }, + { + "ROS": null, + "Terraform": "cache_control", + "Required": false + }, + { + "ROS": null, + "Terraform": "content", + "Required": false + }, + { + "ROS": null, + "Terraform": "content_disposition", + "Required": false + }, + { + "ROS": null, + "Terraform": "content_encoding", + "Required": false + }, + { + "ROS": null, + "Terraform": "content_md5", + "Required": false + }, + { + "ROS": null, + "Terraform": "content_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "expires", + "Required": false + }, + { + "ROS": null, + "Terraform": "key", + "Required": false + }, + { + "ROS": null, + "Terraform": "kms_key_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "server_side_encryption", + "Required": false + }, + { + "ROS": null, + "Terraform": "source", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "content_length" + }, + { + "ROS": null, + "Terraform": "etag" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "version_id" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_oss_bucket_policy" + }, + "ProductCode": "oss", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "bucket", + "Required": false + }, + { + "ROS": null, + "Terraform": "policy", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_oss_bucket_public_access_block" + }, + "ProductCode": "oss", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "block_public_access", + "Required": false + }, + { + "ROS": null, + "Terraform": "bucket", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_oss_bucket_referer" + }, + "ProductCode": "oss", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "allow_empty_referer", + "Required": false + }, + { + "ROS": null, + "Terraform": "allow_truncate_query_string", + "Required": false + }, + { + "ROS": null, + "Terraform": "bucket", + "Required": false + }, + { + "ROS": null, + "Terraform": "referer_blacklist", + "Required": false + }, + { + "ROS": null, + "Terraform": "referer_list", + "Required": false + }, + { + "ROS": null, + "Terraform": "truncate_path", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_oss_bucket_replication" + }, + "ProductCode": "oss", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "action", + "Required": false + }, + { + "ROS": null, + "Terraform": "bucket", + "Required": false + }, + { + "ROS": null, + "Terraform": "destination", + "Required": false + }, + { + "ROS": null, + "Terraform": "encryption_configuration", + "Required": false + }, + { + "ROS": null, + "Terraform": "historical_object_replication", + "Required": false + }, + { + "ROS": null, + "Terraform": "prefix_set", + "Required": false + }, + { + "ROS": null, + "Terraform": "progress", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_selection_criteria", + "Required": false + }, + { + "ROS": null, + "Terraform": "sync_role", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "progress" + }, + { + "ROS": null, + "Terraform": "rule_id" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_oss_bucket_request_payment" + }, + "ProductCode": "oss", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "bucket", + "Required": false + }, + { + "ROS": null, + "Terraform": "payer", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_oss_bucket_server_side_encryption" + }, + "ProductCode": "oss", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "bucket", + "Required": false + }, + { + "ROS": null, + "Terraform": "kms_data_encryption", + "Required": false + }, + { + "ROS": null, + "Terraform": "kms_master_key_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "sse_algorithm", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_oss_bucket_transfer_acceleration" + }, + "ProductCode": "oss", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "bucket", + "Required": false + }, + { + "ROS": null, + "Terraform": "enabled", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_oss_bucket_user_defined_log_fields" + }, + "ProductCode": "oss", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "bucket", + "Required": false + }, + { + "ROS": null, + "Terraform": "header_set", + "Required": false + }, + { + "ROS": null, + "Terraform": "param_set", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_oss_bucket_versioning" + }, + "ProductCode": "oss", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "bucket", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::RDS::ADInfo", + "Terraform": null + }, + "ProductCode": "rds", + "Name": { + "zh": "RDS AD域服务", + "en": "ApsaraDB RDS AD Domain" + }, + "Properties": [ + { + "ROS": "ADAccountName", + "Terraform": null, + "Required": true + }, + { + "ROS": "ADDNS", + "Terraform": null, + "Required": true + }, + { + "ROS": "ADPassword", + "Terraform": null, + "Required": true + }, + { + "ROS": "ADServerIpAddress", + "Terraform": null, + "Required": true + }, + { + "ROS": "DBInstanceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::RDS::DBInstance" + } + ] + } + ], + "Attributes": [ + { + "ROS": "ADDNS", + "Terraform": null, + "Primary": true + }, + { + "ROS": "DBInstanceId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::RDS::Account", + "Terraform": "alicloud_rds_account" + }, + "ProductCode": "rds", + "Name": { + "zh": "RDS数据库账号", + "en": "ApsaraDB RDS Database Account" + }, + "Properties": [ + { + "ROS": "AccountDescription", + "Terraform": "account_description", + "Required": false + }, + { + "ROS": "AccountName", + "Terraform": "account_name", + "Required": true + }, + { + "ROS": "AccountPassword", + "Terraform": "account_password", + "Required": true + }, + { + "ROS": "AccountType", + "Terraform": "account_type", + "Required": false + }, + { + "ROS": "DBInstanceId", + "Terraform": "db_instance_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::RDS::DBInstance" + } + ] + }, + { + "ROS": null, + "Terraform": "kms_encrypted_password", + "Required": false + }, + { + "ROS": null, + "Terraform": "kms_encryption_context", + "Required": false + }, + { + "ROS": null, + "Terraform": "reset_permission_flag", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "AccountName", + "Terraform": null + }, + { + "ROS": "AccountName", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::RDS::AccountPrivilege", + "Terraform": "alicloud_db_account_privilege" + }, + "ProductCode": "rds", + "Name": { + "zh": "授权RDS数据库账号", + "en": "ApsaraDB RDS Account Authorization" + }, + "Properties": [ + { + "ROS": "AccountName", + "Terraform": "account_name", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::RDS::Account" + } + ] + }, + { + "ROS": "DBName", + "Terraform": null, + "Required": true + }, + { + "ROS": null, + "Terraform": "db_names", + "Required": false + }, + { + "ROS": "DBInstanceId", + "Terraform": "instance_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::RDS::DBInstance" + } + ] + }, + { + "ROS": "AccountPrivilege", + "Terraform": "privilege", + "Required": true + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::RDS::Connection", + "Terraform": "alicloud_db_connection" + }, + "ProductCode": "rds", + "Name": { + "zh": "RDS外网连接地址", + "en": "ApsaraDB RDS Public Endpoint" + }, + "Properties": [ + { + "ROS": "BabelfishPort", + "Terraform": "babelfish_port", + "Required": false + }, + { + "ROS": null, + "Terraform": "connection_prefix", + "Required": false + }, + { + "ROS": "ConnectionStringPrefix", + "Terraform": null, + "Required": false + }, + { + "ROS": "DBInstanceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::RDS::DBInstance" + } + ] + }, + { + "ROS": "GeneralGroupName", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::RDS::DBInstance" + } + ] + }, + { + "ROS": "Port", + "Terraform": "port", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "BabelfishPort", + "Terraform": null + }, + { + "ROS": "ConnectionString", + "Terraform": "connection_string" + }, + { + "ROS": "DBInstanceId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "ip_address" + }, + { + "ROS": "Port", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::RDS::DBInstance", + "Terraform": "alicloud_db_instance" + }, + "ProductCode": "rds", + "Name": { + "zh": "RDS数据库实例", + "en": "ApsaraDB RDS Instance" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "acl", + "Required": false + }, + { + "ROS": "AllocatePublicConnection", + "Terraform": null, + "Required": false + }, + { + "ROS": "ArchiveBackupKeepCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "ArchiveBackupKeepPolicy", + "Terraform": null, + "Required": false + }, + { + "ROS": "ArchiveBackupRetentionPeriod", + "Terraform": null, + "Required": false + }, + { + "ROS": "AutoRenew", + "Terraform": "auto_renew", + "Required": false + }, + { + "ROS": null, + "Terraform": "auto_renew_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "auto_upgrade_minor_version", + "Required": false + }, + { + "ROS": null, + "Terraform": "babelfish_config", + "Required": false + }, + { + "ROS": null, + "Terraform": "babelfish_port", + "Required": false + }, + { + "ROS": "BackUpCategory", + "Terraform": null, + "Required": false + }, + { + "ROS": "BackupPolicyMode", + "Terraform": null, + "Required": false + }, + { + "ROS": "BackupRetentionPeriod", + "Terraform": null, + "Required": false + }, + { + "ROS": "BurstingEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "Category", + "Terraform": "category", + "Required": false + }, + { + "ROS": null, + "Terraform": "ca_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "client_ca_cert", + "Required": false + }, + { + "ROS": null, + "Terraform": "client_ca_enabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "client_cert_revocation_list", + "Required": false + }, + { + "ROS": null, + "Terraform": "client_crl_enabled", + "Required": false + }, + { + "ROS": "ColdDataEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "CompressType", + "Terraform": null, + "Required": false + }, + { + "ROS": "ConnectionMode", + "Terraform": null, + "Required": false + }, + { + "ROS": "ConnectionStringPrefix", + "Terraform": "connection_string_prefix", + "Required": false + }, + { + "ROS": "ConnectionStringType", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "db_instance_ip_array_attribute", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_instance_ip_array_name", + "Required": false + }, + { + "ROS": "DBInstanceNetType", + "Terraform": null, + "Required": false + }, + { + "ROS": "DBInstanceStorageType", + "Terraform": "db_instance_storage_type", + "Required": false + }, + { + "ROS": "DBIsIgnoreCase", + "Terraform": "db_is_ignore_case", + "Required": false + }, + { + "ROS": "DBMappings", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "CharacterSetName", + "Terraform": null, + "Required": true + }, + { + "ROS": "DBDescription", + "Terraform": null, + "Required": false + }, + { + "ROS": "DBName", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "DBParamGroupId", + "Terraform": "db_param_group_id", + "Required": false + }, + { + "ROS": "DBTimeZone", + "Terraform": "db_time_zone", + "Required": false + }, + { + "ROS": "DedicatedHostGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CDDC::DedicatedHostGrou" + } + ] + }, + { + "ROS": "DeletionProtection", + "Terraform": "deletion_protection", + "Required": false + }, + { + "ROS": null, + "Terraform": "direction", + "Required": false + }, + { + "ROS": null, + "Terraform": "effective_time", + "Required": false + }, + { + "ROS": "EnableBackupLog", + "Terraform": null, + "Required": false + }, + { + "ROS": "EncryptionKey", + "Terraform": "encryption_key", + "Required": false + }, + { + "ROS": "Engine", + "Terraform": "engine", + "Required": true + }, + { + "ROS": "EngineVersion", + "Terraform": "engine_version", + "Required": true + }, + { + "ROS": null, + "Terraform": "force", + "Required": false + }, + { + "ROS": null, + "Terraform": "force_restart", + "Required": false + }, + { + "ROS": null, + "Terraform": "fresh_white_list_readins", + "Required": false + }, + { + "ROS": null, + "Terraform": "ha_config", + "Required": false + }, + { + "ROS": "HighSpaceUsageProtection", + "Terraform": null, + "Required": false + }, + { + "ROS": "PayType", + "Terraform": "instance_charge_type", + "Required": false + }, + { + "ROS": "DBInstanceDescription", + "Terraform": "instance_name", + "Required": false + }, + { + "ROS": "InstanceNetworkType", + "Terraform": null, + "Required": false + }, + { + "ROS": "DBInstanceStorage", + "Terraform": "instance_storage", + "Required": true + }, + { + "ROS": "DBInstanceClass", + "Terraform": "instance_type", + "Required": true + }, + { + "ROS": "IoAccelerationEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "LocalLogRetentionHours", + "Terraform": null, + "Required": false + }, + { + "ROS": "LocalLogRetentionSpace", + "Terraform": null, + "Required": false + }, + { + "ROS": "LogBackupFrequency", + "Terraform": null, + "Required": false + }, + { + "ROS": "LogBackupLocalRetentionNumber", + "Terraform": null, + "Required": false + }, + { + "ROS": "LogBackupRetentionPeriod", + "Terraform": null, + "Required": false + }, + { + "ROS": "MaintainTime", + "Terraform": "maintain_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "manual_ha_time", + "Required": false + }, + { + "ROS": "MasterUsername", + "Terraform": null, + "Required": false + }, + { + "ROS": "MasterUserPassword", + "Terraform": null, + "Required": false + }, + { + "ROS": "MasterUserType", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "modify_mode", + "Required": false + }, + { + "ROS": null, + "Terraform": "monitoring_period", + "Required": false + }, + { + "ROS": "MultiAZ", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "node_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "parameters", + "Required": false + }, + { + "ROS": "Period", + "Terraform": "period", + "Required": false + }, + { + "ROS": "PeriodType", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "pg_hba_conf", + "Required": false + }, + { + "ROS": "Port", + "Terraform": "port", + "Required": false + }, + { + "ROS": "PreferredBackupPeriod", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "PreferredBackupTime", + "Terraform": null, + "Required": false + }, + { + "ROS": "PrivateIpAddress", + "Terraform": "private_ip_address", + "Required": false + }, + { + "ROS": "ReleasedKeepPolicy", + "Terraform": "released_keep_policy", + "Required": false + }, + { + "ROS": null, + "Terraform": "replication_acl", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "RoleARN", + "Terraform": "role_arn", + "Required": false + }, + { + "ROS": "SecurityGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "security_group_ids", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "security_ip_mode", + "Required": false + }, + { + "ROS": "SecurityIPList", + "Terraform": "security_ips", + "Required": true + }, + { + "ROS": null, + "Terraform": "security_ip_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "server_cert", + "Required": false + }, + { + "ROS": null, + "Terraform": "server_key", + "Required": false + }, + { + "ROS": "ServerlessConfig", + "Terraform": "serverless_config", + "Required": false + }, + { + "ROS": "SlaveZoneIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": null, + "Terraform": "sql_collector_config_value", + "Required": false + }, + { + "ROS": "SQLCollectorStatus", + "Terraform": "sql_collector_status", + "Required": false + }, + { + "ROS": null, + "Terraform": "ssl_action", + "Required": false + }, + { + "ROS": null, + "Terraform": "ssl_connection_string", + "Required": false + }, + { + "ROS": "SSLSetting", + "Terraform": null, + "Required": false + }, + { + "ROS": "StorageAutoScale", + "Terraform": "storage_auto_scale", + "Required": false + }, + { + "ROS": "StorageThreshold", + "Terraform": "storage_threshold", + "Required": false + }, + { + "ROS": "StorageUpperBound", + "Terraform": "storage_upper_bound", + "Required": false + }, + { + "ROS": null, + "Terraform": "switch_time", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "TargetDedicatedHostIdForLog", + "Terraform": null, + "Required": false + }, + { + "ROS": "TargetDedicatedHostIdForMaster", + "Terraform": null, + "Required": false + }, + { + "ROS": "TargetDedicatedHostIdForSlave", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "target_minor_version", + "Required": false + }, + { + "ROS": null, + "Terraform": "tcp_connection_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "tde_status", + "Required": false + }, + { + "ROS": null, + "Terraform": "upgrade_time", + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": null, + "Terraform": "whitelist_network_type", + "Required": false + }, + { + "ROS": "ZoneId", + "Terraform": "zone_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "zone_id_slave_a", + "Required": false + }, + { + "ROS": null, + "Terraform": "zone_id_slave_b", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "connection_string" + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "db_instance_type" + }, + { + "ROS": "DBInstanceId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "InnerConnectionString", + "Terraform": null + }, + { + "ROS": "InnerIPAddress", + "Terraform": null + }, + { + "ROS": "InnerPort", + "Terraform": null + }, + { + "ROS": "PublicConnectionString", + "Terraform": null + }, + { + "ROS": "PublicIPAddress", + "Terraform": null + }, + { + "ROS": "PublicPort", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "ssl_status" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::RDS::DBInstanceClone", + "Terraform": null + }, + "ProductCode": "rds", + "Name": { + "zh": "克隆RDS实例", + "en": "Clone ApsaraDB RDS Instance" + }, + "Properties": [ + { + "ROS": "AllocatePublicConnection", + "Terraform": null, + "Required": false + }, + { + "ROS": "BackupId", + "Terraform": null, + "Required": false + }, + { + "ROS": "BackupRetentionPeriod", + "Terraform": null, + "Required": false + }, + { + "ROS": "BackupType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Category", + "Terraform": null, + "Required": false + }, + { + "ROS": "ConnectionStringPrefix", + "Terraform": null, + "Required": false + }, + { + "ROS": "ConnectionStringType", + "Terraform": null, + "Required": false + }, + { + "ROS": "DBInstanceClass", + "Terraform": null, + "Required": false + }, + { + "ROS": "DBInstanceDescription", + "Terraform": null, + "Required": false + }, + { + "ROS": "DBInstanceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::RDS::DBInstance" + } + ] + }, + { + "ROS": "DBInstanceStorage", + "Terraform": null, + "Required": false + }, + { + "ROS": "DBInstanceStorageType", + "Terraform": null, + "Required": false + }, + { + "ROS": "DBMappings", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "CharacterSetName", + "Terraform": null, + "Required": true + }, + { + "ROS": "DBDescription", + "Terraform": null, + "Required": false + }, + { + "ROS": "DBName", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "DbNames", + "Terraform": null, + "Required": false + }, + { + "ROS": "DedicatedHostGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CDDC::DedicatedHostGroup" + } + ] + }, + { + "ROS": "InstanceNetworkType", + "Terraform": null, + "Required": false + }, + { + "ROS": "MaintainTime", + "Terraform": null, + "Required": false + }, + { + "ROS": "MasterUsername", + "Terraform": null, + "Required": false + }, + { + "ROS": "MasterUserPassword", + "Terraform": null, + "Required": false + }, + { + "ROS": "MasterUserType", + "Terraform": null, + "Required": false + }, + { + "ROS": "PayType", + "Terraform": null, + "Required": true + }, + { + "ROS": "Period", + "Terraform": null, + "Required": false + }, + { + "ROS": "PeriodType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Port", + "Terraform": null, + "Required": false + }, + { + "ROS": "PreferredBackupPeriod", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "PreferredBackupTime", + "Terraform": null, + "Required": false + }, + { + "ROS": "PrivateIpAddress", + "Terraform": null, + "Required": false + }, + { + "ROS": "RestoreTable", + "Terraform": null, + "Required": false + }, + { + "ROS": "RestoreTime", + "Terraform": null, + "Required": false + }, + { + "ROS": "SecurityGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "SecurityIPList", + "Terraform": null, + "Required": false + }, + { + "ROS": "SlaveZoneIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "SQLCollectorStatus", + "Terraform": null, + "Required": false + }, + { + "ROS": "SSLSetting", + "Terraform": null, + "Required": false + }, + { + "ROS": "TableMeta", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Name", + "Terraform": null, + "Required": false + }, + { + "ROS": "NewName", + "Terraform": null, + "Required": false + }, + { + "ROS": "Tables", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Name", + "Terraform": null, + "Required": false + }, + { + "ROS": "NewName", + "Terraform": null, + "Required": false + }, + { + "ROS": "Type", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "Type", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false + }, + { + "ROS": "TimeoutInMinutes", + "Terraform": null, + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "ZoneId", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "DBInstanceId", + "Terraform": null + }, + { + "ROS": "InnerConnectionString", + "Terraform": null + }, + { + "ROS": "InnerIPAddress", + "Terraform": null + }, + { + "ROS": "InnerPort", + "Terraform": null + }, + { + "ROS": "PublicConnectionString", + "Terraform": null + }, + { + "ROS": "PublicIPAddress", + "Terraform": null + }, + { + "ROS": "PublicPort", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::RDS::DBInstanceParameterGroup", + "Terraform": "alicloud_rds_parameter_group" + }, + "ProductCode": "rds", + "Name": { + "zh": "RDS实例参数", + "en": "ApsaraDB RDS Instance Parameters" + }, + "Properties": [ + { + "ROS": "DBInstanceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::RDS::DBInstance" + } + ] + }, + { + "ROS": null, + "Terraform": "engine", + "Required": false + }, + { + "ROS": null, + "Terraform": "engine_version", + "Required": false + }, + { + "ROS": "Forcerestart", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "param_detail", + "Required": false + }, + { + "ROS": null, + "Terraform": "parameter_group_desc", + "Required": false + }, + { + "ROS": null, + "Terraform": "parameter_group_name", + "Required": false + }, + { + "ROS": "Parameters", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::RDS::DBInstanceSecurityIps", + "Terraform": null + }, + "ProductCode": "rds", + "Name": { + "zh": "RDS实例访问白名单", + "en": "ApsaraDB RDS Instance IP Whitelist" + }, + "Properties": [ + { + "ROS": "DBInstanceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::RDS::DBInstance" + } + ] + }, + { + "ROS": "DBInstanceIPArrayAttribute", + "Terraform": null, + "Required": true + }, + { + "ROS": "DBInstanceIPArrayName", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "SecurityIps", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::RDS::Database", + "Terraform": "alicloud_db_database" + }, + "ProductCode": "rds", + "Name": { + "zh": "RDS数据库", + "en": "ApsaraDB RDS Database" + }, + "Properties": [ + { + "ROS": "CharacterSetName", + "Terraform": "character_set", + "Required": true + }, + { + "ROS": "DBDescription", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": "DBInstanceId", + "Terraform": "instance_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::RDS::DBInstance" + } + ] + }, + { + "ROS": "DBName", + "Terraform": "name", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "DBInstanceId", + "Terraform": null + }, + { + "ROS": "DBName", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::RDS::MigrateTask", + "Terraform": null + }, + "ProductCode": "rds", + "Name": { + "zh": "RDS备份文件还原", + "en": "Restore Backup File to ApsaraDB RDS" + }, + "Properties": [ + { + "ROS": "BackupMode", + "Terraform": null, + "Required": true + }, + { + "ROS": "CheckDBMode", + "Terraform": null, + "Required": false + }, + { + "ROS": "DBInstanceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::RDS::DBInstance" + } + ] + }, + { + "ROS": "DBName", + "Terraform": null, + "Required": true + }, + { + "ROS": "IsOnlineDB", + "Terraform": null, + "Required": true + }, + { + "ROS": "OssObjectPositions", + "Terraform": null, + "Required": false + }, + { + "ROS": "OSSUrls", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "DBName", + "Terraform": null + }, + { + "ROS": "MigrateTaskId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::RDS::PostgresExtensions", + "Terraform": null + }, + "ProductCode": "rds", + "Name": { + "zh": "RDS PostgresExtensions", + "en": "ApsaraDB RDS for PostgreSQL Extensions" + }, + "Properties": [ + { + "ROS": "AccountName", + "Terraform": null, + "Required": true + }, + { + "ROS": "DBInstanceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::RDS::DBInstance" + } + ] + }, + { + "ROS": "DBName", + "Terraform": null, + "Required": true + }, + { + "ROS": "Extensions", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "RiskConfirmed", + "Terraform": null, + "Required": false + }, + { + "ROS": "SourceDatabase", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "InstalledExtensionNames", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::RDS::PrepayDBInstance", + "Terraform": null + }, + "ProductCode": "rds", + "Name": { + "zh": "RDS预付费实例", + "en": "ApsaraDB RDS Subscription Instance" + }, + "Properties": [ + { + "ROS": "AllocatePublicConnection", + "Terraform": null, + "Required": false + }, + { + "ROS": "ArchiveBackupKeepCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "ArchiveBackupKeepPolicy", + "Terraform": null, + "Required": false + }, + { + "ROS": "ArchiveBackupRetentionPeriod", + "Terraform": null, + "Required": false + }, + { + "ROS": "AutoPay", + "Terraform": null, + "Required": false + }, + { + "ROS": "AutoRenew", + "Terraform": null, + "Required": false + }, + { + "ROS": "BackUpCategory", + "Terraform": null, + "Required": false + }, + { + "ROS": "BackupPolicyMode", + "Terraform": null, + "Required": false + }, + { + "ROS": "BackupRetentionPeriod", + "Terraform": null, + "Required": false + }, + { + "ROS": "BurstingEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "Category", + "Terraform": null, + "Required": false + }, + { + "ROS": "ColdDataEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "CommodityCode", + "Terraform": null, + "Required": true + }, + { + "ROS": "CompressType", + "Terraform": null, + "Required": false + }, + { + "ROS": "ConnectionMode", + "Terraform": null, + "Required": false + }, + { + "ROS": "ConnectionStringPrefix", + "Terraform": null, + "Required": false + }, + { + "ROS": "ConnectionStringType", + "Terraform": null, + "Required": false + }, + { + "ROS": "CouponCode", + "Terraform": null, + "Required": false + }, + { + "ROS": "DBInstanceClass", + "Terraform": null, + "Required": true + }, + { + "ROS": "DBInstanceDescription", + "Terraform": null, + "Required": false + }, + { + "ROS": "DBInstanceNetType", + "Terraform": null, + "Required": false + }, + { + "ROS": "DBInstanceStorage", + "Terraform": null, + "Required": true + }, + { + "ROS": "DBInstanceStorageType", + "Terraform": null, + "Required": false + }, + { + "ROS": "DBIsIgnoreCase", + "Terraform": null, + "Required": false + }, + { + "ROS": "DBMappings", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "CharacterSetName", + "Terraform": null, + "Required": true + }, + { + "ROS": "DBDescription", + "Terraform": null, + "Required": false + }, + { + "ROS": "DBName", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "DBParamGroupId", + "Terraform": null, + "Required": false + }, + { + "ROS": "DBTimeZone", + "Terraform": null, + "Required": false + }, + { + "ROS": "DedicatedHostGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CDDC::DedicatedHostGroup" + } + ] + }, + { + "ROS": "DeletionProtection", + "Terraform": null, + "Required": false + }, + { + "ROS": "EnableBackupLog", + "Terraform": null, + "Required": false + }, + { + "ROS": "EncryptionKey", + "Terraform": null, + "Required": false + }, + { + "ROS": "Engine", + "Terraform": null, + "Required": true + }, + { + "ROS": "EngineVersion", + "Terraform": null, + "Required": true + }, + { + "ROS": "HighSpaceUsageProtection", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceNetworkType", + "Terraform": null, + "Required": false + }, + { + "ROS": "IoAccelerationEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "LocalLogRetentionHours", + "Terraform": null, + "Required": false + }, + { + "ROS": "LocalLogRetentionSpace", + "Terraform": null, + "Required": false + }, + { + "ROS": "LogBackupFrequency", + "Terraform": null, + "Required": false + }, + { + "ROS": "LogBackupLocalRetentionNumber", + "Terraform": null, + "Required": false + }, + { + "ROS": "LogBackupRetentionPeriod", + "Terraform": null, + "Required": false + }, + { + "ROS": "MaintainTime", + "Terraform": null, + "Required": false + }, + { + "ROS": "MasterUsername", + "Terraform": null, + "Required": false + }, + { + "ROS": "MasterUserPassword", + "Terraform": null, + "Required": false + }, + { + "ROS": "MasterUserType", + "Terraform": null, + "Required": false + }, + { + "ROS": "MultiAZ", + "Terraform": null, + "Required": false + }, + { + "ROS": "Period", + "Terraform": null, + "Required": true + }, + { + "ROS": "PeriodType", + "Terraform": null, + "Required": true + }, + { + "ROS": "Port", + "Terraform": null, + "Required": false + }, + { + "ROS": "PreferredBackupPeriod", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "PreferredBackupTime", + "Terraform": null, + "Required": false + }, + { + "ROS": "PrivateIpAddress", + "Terraform": null, + "Required": false + }, + { + "ROS": "Quantity", + "Terraform": null, + "Required": false + }, + { + "ROS": "ReleasedKeepPolicy", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "RoleARN", + "Terraform": null, + "Required": false + }, + { + "ROS": "SecurityGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "ServerlessConfig", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "AutoPause", + "Terraform": null, + "Required": false + }, + { + "ROS": "MaxCapacity", + "Terraform": null, + "Required": true + }, + { + "ROS": "MinCapacity", + "Terraform": null, + "Required": true + }, + { + "ROS": "SwitchForce", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "SlaveZoneIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "SQLCollectorStatus", + "Terraform": null, + "Required": false + }, + { + "ROS": "SSLSetting", + "Terraform": null, + "Required": false + }, + { + "ROS": "StorageAutoScale", + "Terraform": null, + "Required": false + }, + { + "ROS": "StorageThreshold", + "Terraform": null, + "Required": false + }, + { + "ROS": "StorageUpperBound", + "Terraform": null, + "Required": false + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false + }, + { + "ROS": "TargetDedicatedHostIdForLog", + "Terraform": null, + "Required": false + }, + { + "ROS": "TargetDedicatedHostIdForMaster", + "Terraform": null, + "Required": false + }, + { + "ROS": "TargetDedicatedHostIdForSlave", + "Terraform": null, + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "ZoneId", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "DBInstanceId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "InnerConnectionString", + "Terraform": null + }, + { + "ROS": "InnerIPAddress", + "Terraform": null + }, + { + "ROS": "InnerPort", + "Terraform": null + }, + { + "ROS": "OrderId", + "Terraform": null + }, + { + "ROS": "PublicConnectionString", + "Terraform": null + }, + { + "ROS": "PublicIPAddress", + "Terraform": null + }, + { + "ROS": "PublicPort", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::RDS::ReadOnlyDBInstance", + "Terraform": "alicloud_db_readonly_instance" + }, + "ProductCode": "rds", + "Name": { + "zh": "RDS只读实例", + "en": "ApsaraDB RDS Read-only Instance" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "acl", + "Required": false + }, + { + "ROS": "AutoRenew", + "Terraform": "auto_renew", + "Required": false + }, + { + "ROS": null, + "Terraform": "auto_renew_period", + "Required": false + }, + { + "ROS": "Category", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "ca_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "client_ca_cert", + "Required": false + }, + { + "ROS": null, + "Terraform": "client_ca_enabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "client_cert_revocation_list", + "Required": false + }, + { + "ROS": null, + "Terraform": "client_crl_enabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_instance_ip_array_attribute", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_instance_ip_array_name", + "Required": false + }, + { + "ROS": "DBInstanceStorageType", + "Terraform": "db_instance_storage_type", + "Required": false + }, + { + "ROS": "DedicatedHostGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CDDC::DedicatedHostGrou" + } + ] + }, + { + "ROS": "DeletionProtection", + "Terraform": "deletion_protection", + "Required": false + }, + { + "ROS": null, + "Terraform": "direction", + "Required": false + }, + { + "ROS": null, + "Terraform": "effective_time", + "Required": false + }, + { + "ROS": "EngineVersion", + "Terraform": "engine_version", + "Required": true + }, + { + "ROS": null, + "Terraform": "force_restart", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_charge_type", + "Required": false + }, + { + "ROS": "DBInstanceDescription", + "Terraform": "instance_name", + "Required": false + }, + { + "ROS": "DBInstanceStorage", + "Terraform": "instance_storage", + "Required": true + }, + { + "ROS": "DBInstanceClass", + "Terraform": "instance_type", + "Required": true + }, + { + "ROS": "DBInstanceId", + "Terraform": "master_db_instance_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::RDS::DBInstance" + } + ] + }, + { + "ROS": null, + "Terraform": "modify_mode", + "Required": false + }, + { + "ROS": null, + "Terraform": "parameters", + "Required": false + }, + { + "ROS": "PayType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Period", + "Terraform": "period", + "Required": false + }, + { + "ROS": "PeriodType", + "Terraform": null, + "Required": false + }, + { + "ROS": "PrivateIpAddress", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "replication_acl", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "security_ips", + "Required": false + }, + { + "ROS": null, + "Terraform": "security_ip_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "server_cert", + "Required": false + }, + { + "ROS": null, + "Terraform": "server_key", + "Required": false + }, + { + "ROS": null, + "Terraform": "ssl_enabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "switch_time", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "TargetDedicatedHostIdForMaster", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "target_minor_version", + "Required": false + }, + { + "ROS": null, + "Terraform": "upgrade_db_instance_kernel_version", + "Required": false + }, + { + "ROS": null, + "Terraform": "upgrade_time", + "Required": false + }, + { + "ROS": "VPCId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": null, + "Terraform": "whitelist_network_type", + "Required": false + }, + { + "ROS": "ZoneId", + "Terraform": "zone_id", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "ConnectionString", + "Terraform": "connection_string" + }, + { + "ROS": null, + "Terraform": "engine" + }, + { + "ROS": "DBInstanceId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "Port", + "Terraform": "port" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_rds_backup" + }, + "ProductCode": "rds", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "backup_method", + "Required": false + }, + { + "ROS": null, + "Terraform": "backup_strategy", + "Required": false + }, + { + "ROS": null, + "Terraform": "backup_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "remove_from_state", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "backup_id" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "store_status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_rds_clone_db_instance" + }, + "ProductCode": "rds", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "acl", + "Required": false + }, + { + "ROS": null, + "Terraform": "auto_upgrade_minor_version", + "Required": false + }, + { + "ROS": null, + "Terraform": "backup_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "backup_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "category", + "Required": false + }, + { + "ROS": null, + "Terraform": "ca_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "certificate", + "Required": false + }, + { + "ROS": null, + "Terraform": "client_ca_cert", + "Required": false + }, + { + "ROS": null, + "Terraform": "client_ca_enabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "client_cert_revocation_list", + "Required": false + }, + { + "ROS": null, + "Terraform": "client_crl_enabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "connection_string_prefix", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_instance_class", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_instance_description", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_instance_storage", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_instance_storage_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_names", + "Required": false + }, + { + "ROS": null, + "Terraform": "dedicated_host_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CDDC::DedicatedHostGrou" + } + ] + }, + { + "ROS": null, + "Terraform": "deletion_protection", + "Required": false + }, + { + "ROS": null, + "Terraform": "direction", + "Required": false + }, + { + "ROS": null, + "Terraform": "effective_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "encryption_key", + "Required": false + }, + { + "ROS": null, + "Terraform": "engine", + "Required": false + }, + { + "ROS": null, + "Terraform": "engine_version", + "Required": false + }, + { + "ROS": null, + "Terraform": "force_restart", + "Required": false + }, + { + "ROS": null, + "Terraform": "ha_mode", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_network_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "maintain_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "parameters", + "Required": false + }, + { + "ROS": null, + "Terraform": "password", + "Required": false + }, + { + "ROS": null, + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "period", + "Required": false + }, + { + "ROS": null, + "Terraform": "pg_hba_conf", + "Required": false + }, + { + "ROS": null, + "Terraform": "port", + "Required": false + }, + { + "ROS": null, + "Terraform": "private_ip_address", + "Required": false + }, + { + "ROS": null, + "Terraform": "private_key", + "Required": false + }, + { + "ROS": null, + "Terraform": "released_keep_policy", + "Required": false + }, + { + "ROS": null, + "Terraform": "replication_acl", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "restore_table", + "Required": false + }, + { + "ROS": null, + "Terraform": "restore_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "role_arn", + "Required": false + }, + { + "ROS": null, + "Terraform": "security_ips", + "Required": false + }, + { + "ROS": null, + "Terraform": "server_cert", + "Required": false + }, + { + "ROS": null, + "Terraform": "server_key", + "Required": false + }, + { + "ROS": null, + "Terraform": "serverless_config", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_biz", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_db_instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "ssl_enabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "switch_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "sync_mode", + "Required": false + }, + { + "ROS": null, + "Terraform": "table_meta", + "Required": false + }, + { + "ROS": null, + "Terraform": "tcp_connection_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "tde_status", + "Required": false + }, + { + "ROS": null, + "Terraform": "used_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": null, + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": null, + "Terraform": "zone_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "zone_id_slave_a", + "Required": false + }, + { + "ROS": null, + "Terraform": "zone_id_slave_b", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "connection_string" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_rds_db_instance_endpoint" + }, + "ProductCode": "rds", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "connection_string_prefix", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_instance_endpoint_description", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "node_items", + "Required": false + }, + { + "ROS": null, + "Terraform": "port", + "Required": false + }, + { + "ROS": null, + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": null, + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "connection_string" + }, + { + "ROS": null, + "Terraform": "db_instance_endpoint_id" + }, + { + "ROS": null, + "Terraform": "db_instance_endpoint_type" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "ip_type" + }, + { + "ROS": null, + "Terraform": "private_ip_address" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_rds_db_instance_endpoint_address" + }, + "ProductCode": "rds", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "connection_string_prefix", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_instance_endpoint_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "port", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "connection_string" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "ip_address" + }, + { + "ROS": null, + "Terraform": "ip_type" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_rds_db_node" + }, + "ProductCode": "rds", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "class_code", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "zone_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "node_id" + }, + { + "ROS": null, + "Terraform": "node_region_id" + }, + { + "ROS": null, + "Terraform": "node_role" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_rds_db_proxy" + }, + "ProductCode": "rds", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "db_proxy_connection_prefix", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_proxy_connect_string_port", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_proxy_endpoint_read_write_mode", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_proxy_features", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_proxy_instance_num", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_proxy_instance_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_proxy_ssl_enabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "effective_specific_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "effective_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_network_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "read_only_instance_distribution_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "read_only_instance_max_delay_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "read_only_instance_weight", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "switch_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "upgrade_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": null, + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "db_proxy_connection_string" + }, + { + "ROS": null, + "Terraform": "db_proxy_endpoint_aliases" + }, + { + "ROS": null, + "Terraform": "db_proxy_endpoint_id" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "net_type" + }, + { + "ROS": null, + "Terraform": "ssl_expired_time" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_rds_ddr_instance" + }, + "ProductCode": "rds", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "acl", + "Required": false + }, + { + "ROS": null, + "Terraform": "auto_renew", + "Required": false + }, + { + "ROS": null, + "Terraform": "auto_renew_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "auto_upgrade_minor_version", + "Required": false + }, + { + "ROS": null, + "Terraform": "backup_set_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "ca_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "client_ca_cert", + "Required": false + }, + { + "ROS": null, + "Terraform": "client_ca_enabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "client_cert_revocation_list", + "Required": false + }, + { + "ROS": null, + "Terraform": "client_crl_enabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "connection_string_prefix", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_instance_ip_array_attribute", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_instance_ip_array_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_instance_storage_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "deletion_protection", + "Required": false + }, + { + "ROS": null, + "Terraform": "effective_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "encryption_key", + "Required": false + }, + { + "ROS": null, + "Terraform": "engine", + "Required": false + }, + { + "ROS": null, + "Terraform": "engine_version", + "Required": false + }, + { + "ROS": null, + "Terraform": "force_restart", + "Required": false + }, + { + "ROS": null, + "Terraform": "fresh_white_list_readins", + "Required": false + }, + { + "ROS": null, + "Terraform": "ha_config", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_storage", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "maintain_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "manual_ha_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "modify_mode", + "Required": false + }, + { + "ROS": null, + "Terraform": "monitoring_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "parameters", + "Required": false + }, + { + "ROS": null, + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "period", + "Required": false + }, + { + "ROS": null, + "Terraform": "pg_hba_conf", + "Required": false + }, + { + "ROS": null, + "Terraform": "port", + "Required": false + }, + { + "ROS": null, + "Terraform": "private_ip_address", + "Required": false + }, + { + "ROS": null, + "Terraform": "released_keep_policy", + "Required": false + }, + { + "ROS": null, + "Terraform": "replication_acl", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "restore_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "restore_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "security_group_ids", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "security_ip_mode", + "Required": false + }, + { + "ROS": null, + "Terraform": "security_ips", + "Required": false + }, + { + "ROS": null, + "Terraform": "security_ip_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "server_cert", + "Required": false + }, + { + "ROS": null, + "Terraform": "server_key", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_db_instance_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_region", + "Required": false + }, + { + "ROS": null, + "Terraform": "sql_collector_config_value", + "Required": false + }, + { + "ROS": null, + "Terraform": "sql_collector_status", + "Required": false + }, + { + "ROS": null, + "Terraform": "ssl_action", + "Required": false + }, + { + "ROS": null, + "Terraform": "storage_auto_scale", + "Required": false + }, + { + "ROS": null, + "Terraform": "storage_threshold", + "Required": false + }, + { + "ROS": null, + "Terraform": "storage_upper_bound", + "Required": false + }, + { + "ROS": null, + "Terraform": "switch_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": null, + "Terraform": "target_minor_version", + "Required": false + }, + { + "ROS": null, + "Terraform": "tcp_connection_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "tde_status", + "Required": false + }, + { + "ROS": null, + "Terraform": "upgrade_db_instance_kernel_version", + "Required": false + }, + { + "ROS": null, + "Terraform": "upgrade_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": null, + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": null, + "Terraform": "whitelist_network_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "zone_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "category" + }, + { + "ROS": null, + "Terraform": "connection_string" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "ssl_status" + }, + { + "ROS": null, + "Terraform": "zone_id_slave_a" + }, + { + "ROS": null, + "Terraform": "zone_id_slave_b" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_rds_instance_cross_backup_policy" + }, + "ProductCode": "rds", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "cross_backup_region", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "log_backup_enabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "retention", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "backup_enabled" + }, + { + "ROS": null, + "Terraform": "backup_enabled_time" + }, + { + "ROS": null, + "Terraform": "cross_backup_type" + }, + { + "ROS": null, + "Terraform": "db_instance_status" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "lock_mode" + }, + { + "ROS": null, + "Terraform": "log_backup_enabled_time" + }, + { + "ROS": null, + "Terraform": "retent_type" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_rds_service_linked_role" + }, + "ProductCode": "rds", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "service_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "arn" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "role_id" + }, + { + "ROS": null, + "Terraform": "role_name" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_rds_upgrade_db_instance" + }, + "ProductCode": "rds", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "acl", + "Required": false + }, + { + "ROS": null, + "Terraform": "auto_upgrade_minor_version", + "Required": false + }, + { + "ROS": null, + "Terraform": "ca_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "certificate", + "Required": false + }, + { + "ROS": null, + "Terraform": "client_ca_cert", + "Required": false + }, + { + "ROS": null, + "Terraform": "client_ca_enabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "client_cert_revocation_list", + "Required": false + }, + { + "ROS": null, + "Terraform": "client_crl_enabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "collect_stat_mode", + "Required": false + }, + { + "ROS": null, + "Terraform": "connection_string_prefix", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_instance_class", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_instance_description", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_instance_storage", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_instance_storage_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "dedicated_host_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CDDC::DedicatedHostGrou" + } + ] + }, + { + "ROS": null, + "Terraform": "deletion_protection", + "Required": false + }, + { + "ROS": null, + "Terraform": "direction", + "Required": false + }, + { + "ROS": null, + "Terraform": "effective_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "encryption_key", + "Required": false + }, + { + "ROS": null, + "Terraform": "engine", + "Required": false + }, + { + "ROS": null, + "Terraform": "engine_version", + "Required": false + }, + { + "ROS": null, + "Terraform": "force_restart", + "Required": false + }, + { + "ROS": null, + "Terraform": "ha_mode", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_network_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "maintain_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "parameters", + "Required": false + }, + { + "ROS": null, + "Terraform": "password", + "Required": false + }, + { + "ROS": null, + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "pg_hba_conf", + "Required": false + }, + { + "ROS": null, + "Terraform": "port", + "Required": false + }, + { + "ROS": null, + "Terraform": "private_ip_address", + "Required": false + }, + { + "ROS": null, + "Terraform": "private_key", + "Required": false + }, + { + "ROS": null, + "Terraform": "released_keep_policy", + "Required": false + }, + { + "ROS": null, + "Terraform": "replication_acl", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "role_arn", + "Required": false + }, + { + "ROS": null, + "Terraform": "security_ips", + "Required": false + }, + { + "ROS": null, + "Terraform": "server_cert", + "Required": false + }, + { + "ROS": null, + "Terraform": "server_key", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_biz", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_db_instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "ssl_enabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "switch_over", + "Required": false + }, + { + "ROS": null, + "Terraform": "switch_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "switch_time_mode", + "Required": false + }, + { + "ROS": null, + "Terraform": "sync_mode", + "Required": false + }, + { + "ROS": null, + "Terraform": "target_major_version", + "Required": false + }, + { + "ROS": null, + "Terraform": "tcp_connection_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "tde_status", + "Required": false + }, + { + "ROS": null, + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": null, + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": null, + "Terraform": "zone_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "zone_id_slave_1", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "connection_string" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECI::ContainerGroup", + "Terraform": "alicloud_eci_container_group" + }, + "ProductCode": "eci", + "Name": { + "zh": "ECI容器组", + "en": "Container Group of Elastic Container Instance" + }, + "Properties": [ + { + "ROS": "AcrRegistryInfo", + "Terraform": "acr_registry_info", + "Required": false, + "Properties": [ + { + "ROS": null, + "Terraform": "domains", + "Required": false + }, + { + "ROS": "InstanceId", + "Terraform": "instance_id", + "Required": true + }, + { + "ROS": "InstanceName", + "Terraform": "instance_name", + "Required": false + }, + { + "ROS": "RegionId", + "Terraform": "region_id", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "ActiveDeadlineSeconds", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "auto_create_eip", + "Required": false + }, + { + "ROS": "AutoMatchImageCache", + "Terraform": "auto_match_image_cache", + "Required": false + }, + { + "ROS": "Container", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "Arg", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "Command", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "Cpu", + "Terraform": null, + "Required": false + }, + { + "ROS": "EnvironmentVar", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "FieldRef.FieldPath", + "Terraform": null, + "Required": false + }, + { + "ROS": "Key", + "Terraform": null, + "Required": false + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "Image", + "Terraform": null, + "Required": true + }, + { + "ROS": "ImagePullPolicy", + "Terraform": null, + "Required": false + }, + { + "ROS": "LivenessProbe", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Exec.Command", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "FailureThreshold", + "Terraform": null, + "Required": false + }, + { + "ROS": "HttpGet.Path", + "Terraform": null, + "Required": false + }, + { + "ROS": "HttpGet.Port", + "Terraform": null, + "Required": false + }, + { + "ROS": "HttpGet.Scheme", + "Terraform": null, + "Required": false + }, + { + "ROS": "InitialDelaySeconds", + "Terraform": null, + "Required": false + }, + { + "ROS": "PeriodSeconds", + "Terraform": null, + "Required": false + }, + { + "ROS": "SuccessThreshold", + "Terraform": null, + "Required": false + }, + { + "ROS": "TcpSocket.Port", + "Terraform": null, + "Required": false + }, + { + "ROS": "TimeoutSeconds", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "Memory", + "Terraform": null, + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "Port", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Port", + "Terraform": null, + "Required": false + }, + { + "ROS": "Protocol", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "ReadinessProbe", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Exec.Command", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "FailureThreshold", + "Terraform": null, + "Required": false + }, + { + "ROS": "HttpGet.Path", + "Terraform": null, + "Required": false + }, + { + "ROS": "HttpGet.Port", + "Terraform": null, + "Required": false + }, + { + "ROS": "HttpGet.Scheme", + "Terraform": null, + "Required": false + }, + { + "ROS": "InitialDelaySeconds", + "Terraform": null, + "Required": false + }, + { + "ROS": "PeriodSeconds", + "Terraform": null, + "Required": false + }, + { + "ROS": "SuccessThreshold", + "Terraform": null, + "Required": false + }, + { + "ROS": "TcpSocket.Port", + "Terraform": null, + "Required": false + }, + { + "ROS": "TimeoutSeconds", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "SecurityContext", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Capability.Add", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "ReadOnlyRootFilesystem", + "Terraform": null, + "Required": false + }, + { + "ROS": "RunAsUser", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "Stdin", + "Terraform": null, + "Required": false + }, + { + "ROS": "StdinOnce", + "Terraform": null, + "Required": false + }, + { + "ROS": "Tty", + "Terraform": null, + "Required": false + }, + { + "ROS": "VolumeMount", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "MountPath", + "Terraform": null, + "Required": false + }, + { + "ROS": "MountPropagation", + "Terraform": null, + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": false + }, + { + "ROS": "ReadOnly", + "Terraform": null, + "Required": false + }, + { + "ROS": "SubPath", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "WorkingDir", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "ContainerGroupName", + "Terraform": "container_group_name", + "Required": true + }, + { + "ROS": null, + "Terraform": "containers", + "Required": false + }, + { + "ROS": "Cpu", + "Terraform": "cpu", + "Required": false + }, + { + "ROS": "DnsConfig", + "Terraform": "dns_config", + "Required": false + }, + { + "ROS": null, + "Terraform": "dns_policy", + "Required": false + }, + { + "ROS": null, + "Terraform": "eip_bandwidth", + "Required": false + }, + { + "ROS": "EipInstanceId", + "Terraform": "eip_instance_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::EIP" + } + ] + }, + { + "ROS": "HostAliase", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Hostname", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "Ip", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": null, + "Terraform": "host_aliases", + "Required": false + }, + { + "ROS": "ImageRegistryCredential", + "Terraform": "image_registry_credential", + "Required": false, + "Properties": [ + { + "ROS": "Password", + "Terraform": "password", + "Required": true + }, + { + "ROS": "Server", + "Terraform": "server", + "Required": true + }, + { + "ROS": "UserName", + "Terraform": "user_name", + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "ImageSnapshotId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECI::ImageCache" + }, + { + "ResourceType": "ROS/ALIYUN::ECS::Snapshot" + } + ] + }, + { + "ROS": "InitContainer", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Arg", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "Command", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "Cpu", + "Terraform": null, + "Required": false + }, + { + "ROS": "EnvironmentVar", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "FieldRef.FieldPath", + "Terraform": null, + "Required": false + }, + { + "ROS": "Key", + "Terraform": null, + "Required": false + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "Image", + "Terraform": null, + "Required": false + }, + { + "ROS": "ImagePullPolicy", + "Terraform": null, + "Required": false + }, + { + "ROS": "Memory", + "Terraform": null, + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": false + }, + { + "ROS": "Port", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Port", + "Terraform": null, + "Required": false + }, + { + "ROS": "Protocol", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "SecurityContext", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Capability.Add", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "ReadOnlyRootFilesystem", + "Terraform": null, + "Required": false + }, + { + "ROS": "RunAsUser", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "VolumeMount", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "MountPath", + "Terraform": null, + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": false + }, + { + "ROS": "ReadOnly", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "WorkingDir", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": null, + "Terraform": "init_containers", + "Required": false + }, + { + "ROS": null, + "Terraform": "insecure_registry", + "Required": false + }, + { + "ROS": "InstanceType", + "Terraform": "instance_type", + "Required": false + }, + { + "ROS": "Ipv6AddressCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "Memory", + "Terraform": "memory", + "Required": false + }, + { + "ROS": null, + "Terraform": "plain_http_registry", + "Required": false + }, + { + "ROS": "RamRoleName", + "Terraform": "ram_role_name", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "RestartPolicy", + "Terraform": "restart_policy", + "Required": false + }, + { + "ROS": null, + "Terraform": "security_context", + "Required": false + }, + { + "ROS": "SecurityContextSysctl", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Name", + "Terraform": null, + "Required": false + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "SecurityGroupId", + "Terraform": "security_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "SlsEnable", + "Terraform": null, + "Required": false + }, + { + "ROS": "SpotPriceLimit", + "Terraform": "spot_price_limit", + "Required": false + }, + { + "ROS": "SpotStrategy", + "Terraform": "spot_strategy", + "Required": false + }, + { + "ROS": "Tag", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": "TerminationGracePeriodSeconds", + "Terraform": "termination_grace_period_seconds", + "Required": false + }, + { + "ROS": "Volume", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "ConfigFileVolume.ConfigFileToPath", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Content", + "Terraform": null, + "Required": false + }, + { + "ROS": "Path", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "EmptyDirVolume.Medium", + "Terraform": null, + "Required": false + }, + { + "ROS": "FlexVolume.Driver", + "Terraform": null, + "Required": false + }, + { + "ROS": "FlexVolume.FsType", + "Terraform": null, + "Required": false + }, + { + "ROS": "FlexVolume.Options", + "Terraform": null, + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "NFSVolume.Path", + "Terraform": null, + "Required": false + }, + { + "ROS": "NFSVolume.ReadOnly", + "Terraform": null, + "Required": false + }, + { + "ROS": "NFSVolume.Server", + "Terraform": null, + "Required": false + }, + { + "ROS": "Type", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": null, + "Terraform": "volumes", + "Required": false + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "ZoneId", + "Terraform": "zone_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "ContainerGroupName", + "Terraform": null + }, + { + "ROS": "EniInstanceId", + "Terraform": null + }, + { + "ROS": "ContainerGroupId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "InternetIp", + "Terraform": "internet_ip" + }, + { + "ROS": "IntranetIp", + "Terraform": "intranet_ip" + }, + { + "ROS": "Ipv6Address", + "Terraform": null + }, + { + "ROS": "RegionId", + "Terraform": null + }, + { + "ROS": "SecurityGroupId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "ZoneId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECI::ImageCache", + "Terraform": "alicloud_eci_image_cache" + }, + "ProductCode": "eci", + "Name": { + "zh": "ECI镜像缓存", + "en": "Elastic Container Instance Image Cache" + }, + "Properties": [ + { + "ROS": "AcrRegistryInfo", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Domain", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "InstanceId", + "Terraform": null, + "Required": true + }, + { + "ROS": "InstanceName", + "Terraform": null, + "Required": false + }, + { + "ROS": "RegionId", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "AutoMatchImageCache", + "Terraform": null, + "Required": false + }, + { + "ROS": "EipInstanceId", + "Terraform": "eip_instance_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::EIP" + } + ] + }, + { + "ROS": "ImageCacheName", + "Terraform": "image_cache_name", + "Required": true + }, + { + "ROS": "ImageCacheSize", + "Terraform": "image_cache_size", + "Required": false + }, + { + "ROS": "ImageRegistryCredential", + "Terraform": "image_registry_credential", + "Required": false, + "Properties": [ + { + "ROS": "Password", + "Terraform": "password", + "Required": false + }, + { + "ROS": "Server", + "Terraform": "server", + "Required": false + }, + { + "ROS": "UserName", + "Terraform": "user_name", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "Image", + "Terraform": "images", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::CustomImage" + } + ] + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "RetentionDays", + "Terraform": "retention_days", + "Required": false + }, + { + "ROS": "SecurityGroupId", + "Terraform": "security_group_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "ZoneId", + "Terraform": "zone_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "container_group_id" + }, + { + "ROS": "ImageCacheId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_eci_virtual_node" + }, + "ProductCode": "eci", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "eip_instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "enable_public_network", + "Required": false + }, + { + "ROS": null, + "Terraform": "kube_config", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "security_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": null, + "Terraform": "taints", + "Required": false + }, + { + "ROS": null, + "Terraform": "virtual_node_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": null, + "Terraform": "zone_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::NAS::AccessGroup", + "Terraform": null + }, + "ProductCode": "nas", + "Name": { + "zh": "NAS权限组", + "en": "NAS Permission Group" + }, + "Properties": [ + { + "ROS": "AccessGroupName", + "Terraform": null, + "Required": true + }, + { + "ROS": "AccessGroupType", + "Terraform": null, + "Required": true + }, + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "FileSystemType", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "AccessGroupName", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::NAS::AccessRule", + "Terraform": null + }, + "ProductCode": "nas", + "Name": { + "zh": "NAS权限规则", + "en": "NAS Permission Group Rule" + }, + "Properties": [ + { + "ROS": "AccessGroupName", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::NAS::AccessGroup" + } + ] + }, + { + "ROS": "FileSystemType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Ipv6SourceCidrIp", + "Terraform": null, + "Required": false + }, + { + "ROS": "Priority", + "Terraform": null, + "Required": false + }, + { + "ROS": "RWAccessType", + "Terraform": null, + "Required": false + }, + { + "ROS": "SourceCidrIp", + "Terraform": null, + "Required": false + }, + { + "ROS": "UserAccessType", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "AccessRuleId", + "Terraform": null + }, + { + "ROS": "AccessRuleId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::NAS::DataFlow", + "Terraform": null + }, + "ProductCode": "nas", + "Name": { + "zh": "NAS数据流", + "en": "NAS Data Flow" + }, + "Properties": [ + { + "ROS": "AutoRefreshInterval", + "Terraform": null, + "Required": false + }, + { + "ROS": "AutoRefreshPolicy", + "Terraform": null, + "Required": false + }, + { + "ROS": "AutoRefreshs", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "RefreshPath", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "FileSystemId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::NAS::FileSystem" + } + ] + }, + { + "ROS": "FsetId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::NAS::Fileset" + } + ] + }, + { + "ROS": "SourceSecurityType", + "Terraform": null, + "Required": false + }, + { + "ROS": "SourceStorage", + "Terraform": null, + "Required": true + }, + { + "ROS": "Throughput", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "DataFlowId", + "Terraform": null + }, + { + "ROS": "FileSystemId", + "Terraform": null + }, + { + "ROS": "DataFlowId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::NAS::FileSystem", + "Terraform": null + }, + "ProductCode": "nas", + "Name": { + "zh": "NAS文件系统", + "en": "NAS File System" + }, + "Properties": [ + { + "ROS": "Bandwidth", + "Terraform": null, + "Required": false + }, + { + "ROS": "Capacity", + "Terraform": null, + "Required": false + }, + { + "ROS": "ChargeType", + "Terraform": null, + "Required": false + }, + { + "ROS": "DeletionForce", + "Terraform": null, + "Required": false + }, + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "Duration", + "Terraform": null, + "Required": false + }, + { + "ROS": "EncryptType", + "Terraform": null, + "Required": false + }, + { + "ROS": "FileSystemType", + "Terraform": null, + "Required": false + }, + { + "ROS": "ProtocolType", + "Terraform": null, + "Required": true + }, + { + "ROS": "SnapshotId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Snapshot" + } + ] + }, + { + "ROS": "StorageType", + "Terraform": null, + "Required": true + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "VpcId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "ZoneId", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "FileSystemId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::NAS::Fileset", + "Terraform": null + }, + "ProductCode": "nas", + "Name": { + "zh": "NAS Fileset", + "en": "NAS Fileset" + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "FileSystemId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::NAS::FileSystem" + } + ] + }, + { + "ROS": "FileSystemPath", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "FileSystemId", + "Terraform": null + }, + { + "ROS": "FileSystemPath", + "Terraform": null + }, + { + "ROS": "FsetId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::NAS::MountTarget", + "Terraform": null + }, + "ProductCode": "nas", + "Name": { + "zh": "NAS挂载点", + "en": "NAS Mount Target" + }, + "Properties": [ + { + "ROS": "AccessGroupName", + "Terraform": null, + "Required": true + }, + { + "ROS": "EnableIpv6", + "Terraform": null, + "Required": false + }, + { + "ROS": "FileSystemId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::NAS::FileSystem" + } + ] + }, + { + "ROS": "NetworkType", + "Terraform": null, + "Required": true + }, + { + "ROS": "SecurityGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "Status", + "Terraform": null, + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Attributes": [ + { + "ROS": "MountTargetDomain", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::NAS::ProtocolMountTarget", + "Terraform": null + }, + "ProductCode": "nas", + "Name": { + "zh": "NAS协议服务导出目录", + "en": "NAS Protocol Service Export Directory" + }, + "Properties": [ + { + "ROS": "AccessGroupName", + "Terraform": null, + "Required": false + }, + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "FileSystemId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::NAS::FileSystem" + } + ] + }, + { + "ROS": "FsetId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::NAS::Fileset" + } + ] + }, + { + "ROS": "Path", + "Terraform": null, + "Required": false + }, + { + "ROS": "ProtocolServiceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::NAS::ProtocolService" + } + ] + }, + { + "ROS": "VpcId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Attributes": [ + { + "ROS": "ExportId", + "Terraform": null + }, + { + "ROS": "FileSystemId", + "Terraform": null + }, + { + "ROS": "ProtocolMountTargetDomain", + "Terraform": null, + "Primary": true + }, + { + "ROS": "ProtocolServiceId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::NAS::ProtocolService", + "Terraform": null + }, + "ProductCode": "nas", + "Name": { + "zh": "NAS协议服务", + "en": "NAS Protocol Service" + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "FileSystemId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::NAS::FileSystem" + } + ] + }, + { + "ROS": "ProtocolSpec", + "Terraform": null, + "Required": true + }, + { + "ROS": "ProtocolType", + "Terraform": null, + "Required": true + }, + { + "ROS": "Throughput", + "Terraform": null, + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Attributes": [ + { + "ROS": "FileSystemId", + "Terraform": null + }, + { + "ROS": "ProtocolServiceId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CDN::Domain", + "Terraform": "alicloud_cdn_domain_new" + }, + "ProductCode": "cdn", + "Name": { + "zh": "CDN加速域名", + "en": "CDN Accelerated Domain" + }, + "Properties": [ + { + "ROS": "CdnType", + "Terraform": "cdn_type", + "Required": true + }, + { + "ROS": null, + "Terraform": "certificate_config", + "Required": false + }, + { + "ROS": "CheckUrl", + "Terraform": "check_url", + "Required": false + }, + { + "ROS": "DomainName", + "Terraform": "domain_name", + "Required": true + }, + { + "ROS": "OriginServers", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Content", + "Terraform": null, + "Required": true + }, + { + "ROS": "Port", + "Terraform": null, + "Required": false + }, + { + "ROS": "Priority", + "Terraform": null, + "Required": false + }, + { + "ROS": "Type", + "Terraform": null, + "Required": true + }, + { + "ROS": "Weight", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "Scope", + "Terraform": "scope", + "Required": false + }, + { + "ROS": "Sources", + "Terraform": "sources", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "TopLevelDomain", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": "Cname", + "Terraform": "cname" + }, + { + "ROS": "DomainName", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CDN::DomainConfig", + "Terraform": "alicloud_cdn_domain_config" + }, + "ProductCode": "cdn", + "Name": { + "zh": "配置域名", + "en": "Configure Accelerated Domain" + }, + "Properties": [ + { + "ROS": "DomainNames", + "Terraform": "domain_name", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CDN::Domain" + } + ] + }, + { + "ROS": null, + "Terraform": "function_args", + "Required": false + }, + { + "ROS": "FunctionList", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "FunctionArgs", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "ArgName", + "Terraform": null, + "Required": true + }, + { + "ROS": "ArgValue", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "FunctionName", + "Terraform": null, + "Required": true + }, + { + "ROS": "ParentId", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": null, + "Terraform": "function_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "parent_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "config_id" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cdn_fc_trigger" + }, + "ProductCode": "cdn", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "event_meta_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "event_meta_version", + "Required": false + }, + { + "ROS": null, + "Terraform": "function_arn", + "Required": false + }, + { + "ROS": null, + "Terraform": "notes", + "Required": false + }, + { + "ROS": null, + "Terraform": "role_arn", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_arn", + "Required": false + }, + { + "ROS": null, + "Terraform": "trigger_arn", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cdn_real_time_log_delivery" + }, + "ProductCode": "cdn", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "domain", + "Required": false + }, + { + "ROS": null, + "Terraform": "logstore", + "Required": false + }, + { + "ROS": null, + "Terraform": "project", + "Required": false + }, + { + "ROS": null, + "Terraform": "sls_region", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CloudSSO::AccessAssignment", + "Terraform": "alicloud_cloud_sso_access_assignment" + }, + "ProductCode": "ram", + "Name": { + "zh": "CloudSSO AccessAssignment", + "en": "CloudSSO Access Permission Assignment" + }, + "Properties": [ + { + "ROS": "AccessConfigurationId", + "Terraform": "access_configuration_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CloudSSO::AccessConfiguration" + } + ] + }, + { + "ROS": null, + "Terraform": "deprovision_strategy", + "Required": false + }, + { + "ROS": "DirectoryId", + "Terraform": "directory_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CloudSSO::Directory" + } + ] + }, + { + "ROS": "PrincipalId", + "Terraform": "principal_id", + "Required": true + }, + { + "ROS": "PrincipalType", + "Terraform": "principal_type", + "Required": true + }, + { + "ROS": "TargetId", + "Terraform": "target_id", + "Required": true + }, + { + "ROS": "TargetType", + "Terraform": "target_type", + "Required": true + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CloudSSO::AccessConfiguration", + "Terraform": "alicloud_cloud_sso_access_configuration" + }, + "ProductCode": "ram", + "Name": { + "zh": "CloudSSO 访问配置", + "en": "CloudSSO Access Configuration" + }, + "Properties": [ + { + "ROS": "AccessConfigurationName", + "Terraform": "access_configuration_name", + "Required": true + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "DirectoryId", + "Terraform": "directory_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CloudSSO::Directory" + } + ] + }, + { + "ROS": null, + "Terraform": "force_remove_permission_policies", + "Required": false + }, + { + "ROS": null, + "Terraform": "permission_policies", + "Required": false + }, + { + "ROS": "RelayState", + "Terraform": "relay_state", + "Required": false + }, + { + "ROS": "SessionDuration", + "Terraform": "session_duration", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "AccessConfigurationId", + "Terraform": "access_configuration_id" + }, + { + "ROS": "AccessConfigurationId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CloudSSO::AccessConfigurationProvision", + "Terraform": "alicloud_cloud_sso_access_configuration_provisioning" + }, + "ProductCode": "ram", + "Name": { + "zh": "CloudSSO 访问配置部署", + "en": "CloudSSO Access Configuration Provisioning" + }, + "Properties": [ + { + "ROS": "AccessConfigurationId", + "Terraform": "access_configuration_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CloudSSO::AccessConfiguration" + } + ] + }, + { + "ROS": "DirectoryId", + "Terraform": "directory_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CloudSSO::Directory" + } + ] + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": "TargetId", + "Terraform": "target_id", + "Required": true + }, + { + "ROS": "TargetType", + "Terraform": "target_type", + "Required": true + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CloudSSO::Directory", + "Terraform": "alicloud_cloud_sso_directory" + }, + "ProductCode": "ram", + "Name": { + "zh": "CloudSSO Directory", + "en": "CloudSSO Directory" + }, + "Properties": [ + { + "ROS": "DirectoryName", + "Terraform": "directory_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "mfa_authentication_status", + "Required": false + }, + { + "ROS": null, + "Terraform": "saml_identity_provider_configuration", + "Required": false + }, + { + "ROS": null, + "Terraform": "scim_synchronization_status", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "DirectoryId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CloudSSO::Group", + "Terraform": "alicloud_cloud_sso_group" + }, + "ProductCode": "ram", + "Name": { + "zh": "CloudSSO Group", + "en": "CloudSSO Group" + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "DirectoryId", + "Terraform": "directory_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CloudSSO::Directory" + } + ] + }, + { + "ROS": "GroupName", + "Terraform": "group_name", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "GroupId", + "Terraform": "group_id" + }, + { + "ROS": "GroupId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CloudSSO::PermissionPolicyToAccessConfigurationAddition", + "Terraform": null + }, + "ProductCode": "ram", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "AccessConfigurationId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CloudSSO::AccessConfiguration" + } + ] + }, + { + "ROS": "DirectoryId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CloudSSO::Directory" + } + ] + }, + { + "ROS": "InlinePolicyDocument", + "Terraform": null, + "Required": false + }, + { + "ROS": "PermissionPolicyName", + "Terraform": null, + "Required": true + }, + { + "ROS": "PermissionPolicyType", + "Terraform": null, + "Required": true + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CloudSSO::SAMLIdentityProvider", + "Terraform": null + }, + "ProductCode": "ram", + "Name": { + "zh": "CloudSSO SAMLIdentityProvider", + "en": "CloudSSO SAML IdP" + }, + "Properties": [ + { + "ROS": "DirectoryId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CloudSSO::Directory" + } + ] + }, + { + "ROS": "EncodedMetadataDocument", + "Terraform": null, + "Required": false + }, + { + "ROS": "EntityId", + "Terraform": null, + "Required": false + }, + { + "ROS": "LoginUrl", + "Terraform": null, + "Required": false + }, + { + "ROS": "SSOStatus", + "Terraform": null, + "Required": false + }, + { + "ROS": "WantRequestSigned", + "Terraform": null, + "Required": false + }, + { + "ROS": "X509Certificate", + "Terraform": null, + "Required": false + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CloudSSO::SCIMServerCredential", + "Terraform": "alicloud_cloud_sso_scim_server_credential" + }, + "ProductCode": "ram", + "Name": { + "zh": "CloudSSO SCIMServerCredential", + "en": "CloudSSO SCIM Server Credential" + }, + "Properties": [ + { + "ROS": "DirectoryId", + "Terraform": "directory_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CloudSSO::Directory" + } + ] + }, + { + "ROS": "Status", + "Terraform": "status", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "CredentialId", + "Terraform": "credential_id" + }, + { + "ROS": "CredentialSecret", + "Terraform": null + }, + { + "ROS": "CredentialId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CloudSSO::SCIMSynchronization", + "Terraform": null + }, + "ProductCode": "ram", + "Name": { + "zh": "CloudSSO SCIMSynchronization", + "en": "CloudSSO SCIM Synchronization" + }, + "Properties": [ + { + "ROS": "DirectoryId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CloudSSO::Directory" + } + ] + }, + { + "ROS": "SCIMSynchronizationStatus", + "Terraform": null, + "Required": false + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CloudSSO::User", + "Terraform": "alicloud_cloud_sso_user" + }, + "ProductCode": "ram", + "Name": { + "zh": "CloudSSO User", + "en": "CloudSSO User" + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "DirectoryId", + "Terraform": "directory_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CloudSSO::Directory" + } + ] + }, + { + "ROS": "DisplayName", + "Terraform": "display_name", + "Required": false + }, + { + "ROS": "Email", + "Terraform": "email", + "Required": false + }, + { + "ROS": "FirstName", + "Terraform": "first_name", + "Required": false + }, + { + "ROS": "LastName", + "Terraform": "last_name", + "Required": false + }, + { + "ROS": "Status", + "Terraform": "status", + "Required": false + }, + { + "ROS": "UserName", + "Terraform": "user_name", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "UserId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "UserId", + "Terraform": "user_id" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CloudSSO::UserProvision", + "Terraform": null + }, + "ProductCode": "ram", + "Name": { + "zh": "CloudSSO UserProvision", + "en": "CloudSSO User Provisioning" + }, + "Properties": [ + { + "ROS": "DeletionStrategy", + "Terraform": null, + "Required": true + }, + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "DirectoryId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CloudSSO::Directory" + } + ] + }, + { + "ROS": "DuplicationStrategy", + "Terraform": null, + "Required": true + }, + { + "ROS": "PrincipalId", + "Terraform": null, + "Required": true + }, + { + "ROS": "PrincipalType", + "Terraform": null, + "Required": true + }, + { + "ROS": "TargetId", + "Terraform": null, + "Required": true + }, + { + "ROS": "TargetType", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "UserProvisionId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CloudSSO::UserToGroupAddition", + "Terraform": "alicloud_cloud_sso_user_attachment" + }, + "ProductCode": "ram", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "DirectoryId", + "Terraform": "directory_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CloudSSO::Directory" + } + ] + }, + { + "ROS": "GroupId", + "Terraform": "group_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CloudSSO::Group" + } + ] + }, + { + "ROS": "UserId", + "Terraform": "user_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CloudSSO::User" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::RAM::AccessKey", + "Terraform": "alicloud_ram_access_key" + }, + "ProductCode": "ram", + "Name": { + "zh": "AccessKey", + "en": "AccessKey Pair" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "pgp_key", + "Required": false + }, + { + "ROS": null, + "Terraform": "secret_file", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": "UserName", + "Terraform": "user_name", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "AccessKeySecret", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "encrypted_secret" + }, + { + "ROS": "AccessKeyId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "key_fingerprint" + }, + { + "ROS": null, + "Terraform": "secret" + }, + { + "ROS": "Status", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::RAM::AppSecret", + "Terraform": null + }, + "ProductCode": "ram", + "Name": { + "zh": "RAM AppSecret", + "en": "RAM Application Secret" + }, + "Properties": [ + { + "ROS": "AppId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::RAM::Application" + } + ] + } + ], + "Attributes": [ + { + "ROS": "AppSecretId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "AppSecretValue", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::RAM::Application", + "Terraform": null + }, + "ProductCode": "ram", + "Name": { + "zh": "RAM Application", + "en": "RAM Application" + }, + "Properties": [ + { + "ROS": "AccessTokenValidity", + "Terraform": null, + "Required": false + }, + { + "ROS": "AppName", + "Terraform": null, + "Required": true + }, + { + "ROS": "AppType", + "Terraform": null, + "Required": true + }, + { + "ROS": "DisplayName", + "Terraform": null, + "Required": true + }, + { + "ROS": "IsMultiTenant", + "Terraform": null, + "Required": false + }, + { + "ROS": "PredefinedScopes", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "RedirectUris", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "RefreshTokenValidity", + "Terraform": null, + "Required": false + }, + { + "ROS": "RequiredScopes", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "SecretRequired", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "AppId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "AppName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::RAM::AttachPolicyToGroup", + "Terraform": null + }, + "ProductCode": "ram", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "GroupName", + "Terraform": null, + "Required": true + }, + { + "ROS": "PolicyName", + "Terraform": null, + "Required": true + }, + { + "ROS": "PolicyType", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "GroupName", + "Terraform": null + }, + { + "ROS": "PolicyName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::RAM::AttachPolicyToRole", + "Terraform": "alicloud_ram_role_policy_attachment" + }, + "ProductCode": "ram", + "Name": { + "zh": "指定角色授予权限策略", + "en": "Attach Policy to Role" + }, + "Properties": [ + { + "ROS": "PolicyName", + "Terraform": "policy_name", + "Required": true + }, + { + "ROS": "PolicyType", + "Terraform": "policy_type", + "Required": true + }, + { + "ROS": "RoleName", + "Terraform": "role_name", + "Required": true + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::RAM::AttachPolicyToUser", + "Terraform": "alicloud_ram_user_policy_attachment" + }, + "ProductCode": "ram", + "Name": { + "zh": "指定用户添加权限", + "en": "Attach Policy to User" + }, + "Properties": [ + { + "ROS": "PolicyName", + "Terraform": "policy_name", + "Required": true + }, + { + "ROS": "PolicyType", + "Terraform": "policy_type", + "Required": true + }, + { + "ROS": "UserName", + "Terraform": "user_name", + "Required": true + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::RAM::Group", + "Terraform": "alicloud_ram_group" + }, + "ProductCode": "ram", + "Name": { + "zh": "RAM用户组", + "en": "RAM User Group" + }, + "Properties": [ + { + "ROS": "Comments", + "Terraform": "comments", + "Required": false + }, + { + "ROS": "DeletionForce", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "force", + "Required": false + }, + { + "ROS": "IgnoreExisting", + "Terraform": null, + "Required": false + }, + { + "ROS": "GroupName", + "Terraform": "name", + "Required": true + }, + { + "ROS": "Policies", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "IgnoreExisting", + "Terraform": null, + "Required": false + }, + { + "ROS": "PolicyDocument", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "Statement", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "Action", + "Terraform": null, + "Required": false + }, + { + "ROS": "Condition", + "Terraform": null, + "Required": false + }, + { + "ROS": "Effect", + "Terraform": null, + "Required": false + }, + { + "ROS": "Resource", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "Version", + "Terraform": null, + "Required": true + } + ] + }, + { + "ROS": "PolicyName", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "PolicyAttachments", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Custom", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "System", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + } + ] + } + ], + "Attributes": [ + { + "ROS": "GroupName", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::RAM::LoginProfile", + "Terraform": "alicloud_ram_login_profile" + }, + "ProductCode": "ram", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "GenerateRandomPassword", + "Terraform": null, + "Required": false + }, + { + "ROS": "MFABindRequired", + "Terraform": "mfa_bind_required", + "Required": false + }, + { + "ROS": "Password", + "Terraform": "password", + "Required": false + }, + { + "ROS": "PasswordResetRequired", + "Terraform": "password_reset_required", + "Required": false + }, + { + "ROS": "Status", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "user_name", + "Required": false + }, + { + "ROS": "UserPrincipalName", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "Password", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::RAM::ManagedPolicy", + "Terraform": "alicloud_ram_policy" + }, + "ProductCode": "ram", + "Name": { + "zh": "RAM管理策略", + "en": "RAM Policy" + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "force", + "Required": false + }, + { + "ROS": "Groups", + "Terraform": null, + "Required": false + }, + { + "ROS": "IgnoreExisting", + "Terraform": null, + "Required": false + }, + { + "ROS": "PolicyDocument", + "Terraform": "policy_document", + "Required": false + }, + { + "ROS": "PolicyDocumentUnchecked", + "Terraform": null, + "Required": false + }, + { + "ROS": "PolicyName", + "Terraform": "policy_name", + "Required": true + }, + { + "ROS": "Roles", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "rotate_strategy", + "Required": false + }, + { + "ROS": "Users", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "attachment_count" + }, + { + "ROS": null, + "Terraform": "default_version" + }, + { + "ROS": "PolicyName", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "type" + }, + { + "ROS": null, + "Terraform": "version_id" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::RAM::OIDCProvider", + "Terraform": null + }, + "ProductCode": "ram", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "ClientIds", + "Terraform": null, + "Required": false, + "Type": "list", + "Properties": {} + }, + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "Fingerprints", + "Terraform": null, + "Required": true, + "Type": "list", + "Properties": {} + }, + { + "ROS": "IssuanceLimitTime", + "Terraform": null, + "Required": false + }, + { + "ROS": "IssuerUrl", + "Terraform": null, + "Required": true + }, + { + "ROS": "OIDCProviderName", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "OIDCProviderName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::RAM::RamAccountAlias", + "Terraform": "alicloud_ram_account_alias" + }, + "ProductCode": "ram", + "Name": { + "zh": "RAM账号别名", + "en": "RAM Account Alias" + }, + "Properties": [ + { + "ROS": "AccountAlias", + "Terraform": "account_alias", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "AccountAlias", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::RAM::Role", + "Terraform": "alicloud_ram_role" + }, + "ProductCode": "ram", + "Name": { + "zh": "RAM角色", + "en": "RAM Role" + }, + "Properties": [ + { + "ROS": "DeletionForce", + "Terraform": null, + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "AssumeRolePolicyDocument", + "Terraform": "document", + "Required": true + }, + { + "ROS": null, + "Terraform": "force", + "Required": false + }, + { + "ROS": "IgnoreExisting", + "Terraform": null, + "Required": false + }, + { + "ROS": "MaxSessionDuration", + "Terraform": "max_session_duration", + "Required": false + }, + { + "ROS": "RoleName", + "Terraform": "name", + "Required": true + }, + { + "ROS": "Policies", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "IgnoreExisting", + "Terraform": null, + "Required": false + }, + { + "ROS": "PolicyDocument", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "Statement", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "Action", + "Terraform": null, + "Required": false + }, + { + "ROS": "Condition", + "Terraform": null, + "Required": false + }, + { + "ROS": "Effect", + "Terraform": null, + "Required": false + }, + { + "ROS": "Resource", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "Version", + "Terraform": null, + "Required": true + } + ] + }, + { + "ROS": "PolicyName", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "PolicyAttachments", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Custom", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "System", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + } + ] + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": "arn" + }, + { + "ROS": "RoleName", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "RoleId", + "Terraform": "role_id" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::RAM::SAMLProvider", + "Terraform": "alicloud_ram_saml_provider" + }, + "ProductCode": "ram", + "Name": { + "zh": "RAM角色SSO身份提供商", + "en": "RAM IdP for Role-based SSO" + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "SAMLMetadataDocument", + "Terraform": "encodedsaml_metadata_document", + "Required": false + }, + { + "ROS": "SAMLMetadataDocumentURL", + "Terraform": null, + "Required": false + }, + { + "ROS": "SAMLProviderName", + "Terraform": "saml_provider_name", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": "arn" + }, + { + "ROS": "SAMLProviderName", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "update_date" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::RAM::SecurityPreference", + "Terraform": "alicloud_ram_security_preference" + }, + "ProductCode": "ram", + "Name": { + "zh": "RAM全局安全首选项", + "en": "RAM Global Security Preferences" + }, + "Properties": [ + { + "ROS": "AllowUserToChangePassword", + "Terraform": "allow_user_to_change_password", + "Required": false + }, + { + "ROS": "AllowUserToManageAccessKeys", + "Terraform": "allow_user_to_manage_access_keys", + "Required": false + }, + { + "ROS": "AllowUserToManageMFADevices", + "Terraform": "allow_user_to_manage_mfa_devices", + "Required": false + }, + { + "ROS": "AllowUserToManagePublicKeys", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "enable_save_mfa_ticket", + "Required": false + }, + { + "ROS": "EnableSaveMFATicket", + "Terraform": "enforce_mfa_for_login", + "Required": false + }, + { + "ROS": "LoginNetworkMasks", + "Terraform": "login_network_masks", + "Required": false + }, + { + "ROS": "LoginSessionDuration", + "Terraform": "login_session_duration", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "AllowUserToChangePassword", + "Terraform": null + }, + { + "ROS": "AllowUserToManageAccessKeys", + "Terraform": null + }, + { + "ROS": "AllowUserToManageMFADevices", + "Terraform": null + }, + { + "ROS": "AllowUserToManagePublicKeys", + "Terraform": null + }, + { + "ROS": "EnableSaveMFATicket", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "LoginNetworkMasks", + "Terraform": null + }, + { + "ROS": "LoginSessionDuration", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::RAM::User", + "Terraform": "alicloud_ram_user" + }, + "ProductCode": "ram", + "Name": { + "zh": "RAM用户", + "en": "RAM User" + }, + "Properties": [ + { + "ROS": "Comments", + "Terraform": "comments", + "Required": false + }, + { + "ROS": "DeletionForce", + "Terraform": null, + "Required": false + }, + { + "ROS": "DisplayName", + "Terraform": "display_name", + "Required": false + }, + { + "ROS": "Email", + "Terraform": "email", + "Required": false + }, + { + "ROS": null, + "Terraform": "force", + "Required": false + }, + { + "ROS": "Groups", + "Terraform": null, + "Required": false + }, + { + "ROS": "LoginProfile", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "MFABindRequired", + "Terraform": null, + "Required": false + }, + { + "ROS": "Password", + "Terraform": null, + "Required": false + }, + { + "ROS": "PasswordResetRequired", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "MobilePhone", + "Terraform": "mobile", + "Required": false + }, + { + "ROS": "UserName", + "Terraform": "name", + "Required": true + }, + { + "ROS": "Policies", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::RAM::ManagedPolicy" + } + ], + "Properties": [ + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "IgnoreExisting", + "Terraform": null, + "Required": false + }, + { + "ROS": "PolicyDocument", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "Statement", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "Action", + "Terraform": null, + "Required": false + }, + { + "ROS": "Condition", + "Terraform": null, + "Required": false + }, + { + "ROS": "Effect", + "Terraform": null, + "Required": false + }, + { + "ROS": "Resource", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "Version", + "Terraform": null, + "Required": true + } + ] + }, + { + "ROS": "PolicyName", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "PolicyAttachments", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Custom", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "System", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + } + ] + } + ], + "Attributes": [ + { + "ROS": "CreateDate", + "Terraform": null + }, + { + "ROS": "UserId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "LastLoginDate", + "Terraform": null + }, + { + "ROS": "UserName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::RAM::UserToGroupAddition", + "Terraform": null + }, + "ProductCode": "ram", + "Name": { + "zh": "加入RAM群组", + "en": "Add Users to User Group" + }, + "Properties": [ + { + "ROS": "GroupName", + "Terraform": null, + "Required": true + }, + { + "ROS": "Users", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::RAM::User" + } + ] + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ram_account_password_policy" + }, + "ProductCode": "ram", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "hard_expiry", + "Required": false + }, + { + "ROS": null, + "Terraform": "max_login_attempts", + "Required": false + }, + { + "ROS": null, + "Terraform": "max_password_age", + "Required": false + }, + { + "ROS": null, + "Terraform": "minimum_password_length", + "Required": false + }, + { + "ROS": null, + "Terraform": "password_reuse_prevention", + "Required": false + }, + { + "ROS": null, + "Terraform": "require_lowercase_characters", + "Required": false + }, + { + "ROS": null, + "Terraform": "require_numbers", + "Required": false + }, + { + "ROS": null, + "Terraform": "require_symbols", + "Required": false + }, + { + "ROS": null, + "Terraform": "require_uppercase_characters", + "Required": false + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ram_group_membership" + }, + "ProductCode": "ram", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "group_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "user_names", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ram_group_policy_attachment" + }, + "ProductCode": "ram", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "group_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "policy_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "policy_type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ram_role_attachment" + }, + "ProductCode": "ram", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "instance_ids", + "Required": false + }, + { + "ROS": null, + "Terraform": "role_name", + "Required": false + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ROS::Assert", + "Terraform": null + }, + "ProductCode": "ros", + "Name": { + "zh": "ROS Assert", + "en": "ROS Assert" + }, + "Properties": [ + { + "ROS": "AbortCreation", + "Terraform": null, + "Required": false + }, + { + "ROS": "ErrorMessage", + "Terraform": null, + "Required": false + }, + { + "ROS": "Operation", + "Terraform": null, + "Required": false + }, + { + "ROS": "Values", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "FailureCause", + "Terraform": null + }, + { + "ROS": "Result", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ROS::AutoEnableService", + "Terraform": null + }, + "ProductCode": "ros", + "Name": { + "zh": "开通云服务", + "en": "Activate Service" + }, + "Properties": [ + { + "ROS": "ServiceName", + "Terraform": null, + "Required": true + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ROS::CustomResource", + "Terraform": null + }, + "ProductCode": "ros", + "Name": { + "zh": "自定义资源", + "en": "Custom Resource" + }, + "Properties": [ + { + "ROS": "HttpConfig", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "ContentType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Headers", + "Terraform": null, + "Required": false + }, + { + "ROS": "SignKey", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "Parameters", + "Terraform": null, + "Required": false + }, + { + "ROS": "ServiceToken", + "Terraform": null, + "Required": true + }, + { + "ROS": "Timeout", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "*", + "Terraform": null + }, + { + "ROS": "Outputs", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ROS::ResourceCleaner", + "Terraform": null + }, + "ProductCode": "ros", + "Name": { + "zh": "ROS资源清理器", + "en": "ROS Resource Cleaner" + }, + "Properties": [ + { + "ROS": "Action", + "Terraform": null, + "Required": true + }, + { + "ROS": "CleanUpAlgorithm", + "Terraform": null, + "Required": false + }, + { + "ROS": "CleanUpRetryCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "CleanUpTimeout", + "Terraform": null, + "Required": false + }, + { + "ROS": "DisabledSideEffects", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "ExcludedResources", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "RegionId", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceId", + "Terraform": null, + "Required": true + }, + { + "ROS": "ResourceType", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "FailureOption", + "Terraform": null, + "Required": false + }, + { + "ROS": "Mode", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceFilters", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Effect", + "Terraform": null, + "Required": false + }, + { + "ROS": "IncludeDeletionProtection", + "Terraform": null, + "Required": false + }, + { + "ROS": "RegionIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "ResourceGroupIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "ResourceIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "ResourceNamePatterns", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "ResourceTypePatterns", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + } + ], + "Type": "list" + }, + { + "ROS": "Resources", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "RegionId", + "Terraform": null, + "Required": true + }, + { + "ROS": "ResourceId", + "Terraform": null, + "Required": true + }, + { + "ROS": "ResourceType", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "ResourceTypeOrder", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "CleanResult", + "Terraform": null + }, + { + "ROS": "NoCleanupResourceDetails", + "Terraform": null + }, + { + "ROS": "NoCleanupResourcePartialDetails", + "Terraform": null + }, + { + "ROS": "ResourceDetails", + "Terraform": null + }, + { + "ROS": "ResourcePartialDetails", + "Terraform": null + }, + { + "ROS": "ResourceSummary", + "Terraform": null + }, + { + "ROS": "ScanErrors", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ROS::Sleep", + "Terraform": null + }, + "ProductCode": "ros", + "Name": { + "zh": "ROS延迟操作", + "en": "ROS Delay Action" + }, + "Properties": [ + { + "ROS": "CreateDuration", + "Terraform": null, + "Required": false + }, + { + "ROS": "DeleteDuration", + "Terraform": null, + "Required": false + }, + { + "ROS": "Triggers", + "Terraform": null, + "Required": false + }, + { + "ROS": "UpdateDuration", + "Terraform": null, + "Required": false + }, + { + "ROS": "UpdateRollbackDuration", + "Terraform": null, + "Required": false + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ROS::Stack", + "Terraform": "alicloud_ros_stack" + }, + "ProductCode": "ros", + "Name": { + "zh": "ROS资源栈", + "en": "ROS Stack" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "create_option", + "Required": false + }, + { + "ROS": null, + "Terraform": "deletion_protection", + "Required": false + }, + { + "ROS": null, + "Terraform": "disable_rollback", + "Required": false + }, + { + "ROS": null, + "Terraform": "notification_urls", + "Required": false + }, + { + "ROS": null, + "Terraform": "parameter_key", + "Required": false + }, + { + "ROS": "Parameters", + "Terraform": "parameters", + "Required": false + }, + { + "ROS": null, + "Terraform": "parameter_value", + "Required": false + }, + { + "ROS": null, + "Terraform": "ram_role_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "replacement_option", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "retain_all_resources", + "Required": false + }, + { + "ROS": null, + "Terraform": "retain_resources", + "Required": false + }, + { + "ROS": null, + "Terraform": "stack_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "stack_policy_body", + "Required": false + }, + { + "ROS": null, + "Terraform": "stack_policy_during_update_body", + "Required": false + }, + { + "ROS": null, + "Terraform": "stack_policy_during_update_url", + "Required": false + }, + { + "ROS": null, + "Terraform": "stack_policy_url", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "TemplateBody", + "Terraform": "template_body", + "Required": false + }, + { + "ROS": "TemplateId", + "Terraform": null, + "Required": false + }, + { + "ROS": "TemplateURL", + "Terraform": "template_url", + "Required": false + }, + { + "ROS": "TemplateVersion", + "Terraform": "template_version", + "Required": false + }, + { + "ROS": "TimeoutMins", + "Terraform": "timeout_in_minutes", + "Required": false + }, + { + "ROS": null, + "Terraform": "use_previous_parameters", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ROS::StackGroup", + "Terraform": "alicloud_ros_stack_group" + }, + "ProductCode": "ros", + "Name": { + "zh": "ROS资源栈组", + "en": "ROS Stack Group" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "account_ids", + "Required": false + }, + { + "ROS": "AdministrationRoleName", + "Terraform": "administration_role_name", + "Required": false + }, + { + "ROS": "AutoDeployment", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Enabled", + "Terraform": null, + "Required": true + }, + { + "ROS": "RetainStacksOnAccountRemoval", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "DynamicTemplateBody", + "Terraform": null, + "Required": false + }, + { + "ROS": "ExecutionRoleName", + "Terraform": "execution_role_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "operation_description", + "Required": false + }, + { + "ROS": null, + "Terraform": "operation_preferences", + "Required": false + }, + { + "ROS": null, + "Terraform": "parameter_key", + "Required": false + }, + { + "ROS": "Parameters", + "Terraform": "parameters", + "Required": false + }, + { + "ROS": null, + "Terraform": "parameter_value", + "Required": false + }, + { + "ROS": "PermissionModel", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "region_ids", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "StackGroupName", + "Terraform": "stack_group_name", + "Required": true + }, + { + "ROS": "TemplateBody", + "Terraform": "template_body", + "Required": false + }, + { + "ROS": "TemplateId", + "Terraform": null, + "Required": false + }, + { + "ROS": "TemplateURL", + "Terraform": "template_url", + "Required": false + }, + { + "ROS": "TemplateVersion", + "Terraform": "template_version", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "StackGroupId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "StackGroupId", + "Terraform": "stack_group_id" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ROS::StackInstances", + "Terraform": "alicloud_ros_stack_instance" + }, + "ProductCode": "ros", + "Name": { + "zh": "ROS资源栈实例", + "en": "ROS Stack Instances" + }, + "Properties": [ + { + "ROS": "DeploymentTargets", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "RdFolderIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + } + ] + }, + { + "ROS": "DisableRollback", + "Terraform": null, + "Required": false + }, + { + "ROS": "OperationDescription", + "Terraform": "operation_description", + "Required": false + }, + { + "ROS": "OperationPreferences", + "Terraform": "operation_preferences", + "Required": false + }, + { + "ROS": null, + "Terraform": "parameter_key", + "Required": false + }, + { + "ROS": "ParameterOverrides", + "Terraform": "parameter_overrides", + "Required": false + }, + { + "ROS": null, + "Terraform": "parameter_value", + "Required": false + }, + { + "ROS": "RetainStacks", + "Terraform": "retain_stacks", + "Required": false + }, + { + "ROS": "StackGroupName", + "Terraform": "stack_group_name", + "Required": true + }, + { + "ROS": "AccountIds.0", + "Terraform": "stack_instance_account_id", + "Required": false + }, + { + "ROS": "RegionIds.0", + "Terraform": "stack_instance_region_id", + "Required": false + }, + { + "ROS": "TimeoutInMinutes", + "Terraform": "timeout_in_minutes", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "LastOperationId", + "Terraform": null + }, + { + "ROS": "Stacks", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ROS::TemplateScratch", + "Terraform": "alicloud_ros_template_scratch" + }, + "ProductCode": "ros", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "execution_mode", + "Required": false + }, + { + "ROS": "LogicalIdStrategy", + "Terraform": "logical_id_strategy", + "Required": false + }, + { + "ROS": null, + "Terraform": "parameter_key", + "Required": false + }, + { + "ROS": null, + "Terraform": "parameter_value", + "Required": false + }, + { + "ROS": "PreferenceParameters", + "Terraform": "preference_parameters", + "Required": false, + "Properties": [ + { + "ROS": "ParameterKey", + "Terraform": "parameter_key", + "Required": true + }, + { + "ROS": "ParameterValue", + "Terraform": "parameter_value", + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "resource_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_tags", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_type_filter", + "Required": false + }, + { + "ROS": "SourceResourceGroup", + "Terraform": "source_resource_group", + "Required": false + }, + { + "ROS": "SourceResources", + "Terraform": "source_resources", + "Required": false, + "Properties": [ + { + "ROS": "ResourceId", + "Terraform": "resource_id", + "Required": true + }, + { + "ROS": "ResourceType", + "Terraform": "resource_type", + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "SourceTag", + "Terraform": "source_tag", + "Required": false + }, + { + "ROS": "TemplateScratchType", + "Terraform": "template_scratch_type", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "TemplateScratchId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ROS::WaitCondition", + "Terraform": null + }, + "ProductCode": "ros", + "Name": { + "zh": "ROS等待信号", + "en": "Wait for Signal in ROS" + }, + "Properties": [ + { + "ROS": "Count", + "Terraform": null, + "Required": false + }, + { + "ROS": "Handle", + "Terraform": null, + "Required": true + }, + { + "ROS": "ShowProgressEvent", + "Terraform": null, + "Required": false + }, + { + "ROS": "Timeout", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "Data", + "Terraform": null + }, + { + "ROS": "ErrorData", + "Terraform": null + }, + { + "ROS": "JoinedErrorData", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ROS::WaitConditionHandle", + "Terraform": null + }, + "ProductCode": "ros", + "Name": { + "zh": "ROS接收信号", + "en": "Receive Signal in ROS" + }, + "Properties": [ + { + "ROS": "Count", + "Terraform": null, + "Required": false + }, + { + "ROS": "Mode", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "CurlCli", + "Terraform": null + }, + { + "ROS": "Headers", + "Terraform": null + }, + { + "ROS": "PowerShellCurlCli", + "Terraform": null + }, + { + "ROS": "URL", + "Terraform": null + }, + { + "ROS": "WindowsCurlCli", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ros_change_set" + }, + "ProductCode": "ros", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "change_set_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "change_set_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "disable_rollback", + "Required": false + }, + { + "ROS": null, + "Terraform": "notification_urls", + "Required": false + }, + { + "ROS": null, + "Terraform": "parameter_key", + "Required": false + }, + { + "ROS": null, + "Terraform": "parameters", + "Required": false + }, + { + "ROS": null, + "Terraform": "parameter_value", + "Required": false + }, + { + "ROS": null, + "Terraform": "ram_role_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "replacement_option", + "Required": false + }, + { + "ROS": null, + "Terraform": "stack_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "stack_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "stack_policy_body", + "Required": false + }, + { + "ROS": null, + "Terraform": "stack_policy_during_update_body", + "Required": false + }, + { + "ROS": null, + "Terraform": "stack_policy_during_update_url", + "Required": false + }, + { + "ROS": null, + "Terraform": "stack_policy_url", + "Required": false + }, + { + "ROS": null, + "Terraform": "template_body", + "Required": false + }, + { + "ROS": null, + "Terraform": "template_url", + "Required": false + }, + { + "ROS": null, + "Terraform": "timeout_in_minutes", + "Required": false + }, + { + "ROS": null, + "Terraform": "use_previous_parameters", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ros_template" + }, + "ProductCode": "ros", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": null, + "Terraform": "template_body", + "Required": false + }, + { + "ROS": null, + "Terraform": "template_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "template_url", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::OOS::DefaultPatchBaseline", + "Terraform": "alicloud_oos_default_patch_baseline" + }, + "ProductCode": "oos", + "Name": { + "zh": "OOS默认补丁基线", + "en": "OOS Default Patch Baseline" + }, + "Properties": [ + { + "ROS": "PatchBaselineName", + "Terraform": "patch_baseline_name", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "ApprovalRules", + "Terraform": null + }, + { + "ROS": "CreatedBy", + "Terraform": null + }, + { + "ROS": "CreatedDate", + "Terraform": null + }, + { + "ROS": "Description", + "Terraform": null + }, + { + "ROS": "PatchBaselineId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "OperationSystem", + "Terraform": null + }, + { + "ROS": "PatchBaselineId", + "Terraform": "patch_baseline_id" + }, + { + "ROS": "PatchBaselineName", + "Terraform": null + }, + { + "ROS": "ShareType", + "Terraform": null + }, + { + "ROS": "UpdatedBy", + "Terraform": null + }, + { + "ROS": "UpdatedDate", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::OOS::Execution", + "Terraform": "alicloud_oos_execution" + }, + "ProductCode": "oos", + "Name": { + "zh": "OOS执行", + "en": "OOS Execution" + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "LoopMode", + "Terraform": "loop_mode", + "Required": false + }, + { + "ROS": "Mode", + "Terraform": "mode", + "Required": false + }, + { + "ROS": "Parameters", + "Terraform": "parameters", + "Required": false + }, + { + "ROS": "ParentExecutionId", + "Terraform": "parent_execution_id", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "ResourceOptions", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "CancelOnDelete", + "Terraform": null, + "Required": false + }, + { + "ROS": "FailureStatuses", + "Terraform": null, + "Required": false + }, + { + "ROS": "SuccessStatuses", + "Terraform": null, + "Required": false + }, + { + "ROS": "Timeout", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "SafetyCheck", + "Terraform": "safety_check", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false + }, + { + "ROS": "TemplateContent", + "Terraform": "template_content", + "Required": false + }, + { + "ROS": "TemplateName", + "Terraform": "template_name", + "Required": false + }, + { + "ROS": "TemplateURL", + "Terraform": null, + "Required": false + }, + { + "ROS": "TemplateVersion", + "Terraform": "template_version", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Counters", + "Terraform": "counters" + }, + { + "ROS": null, + "Terraform": "create_date" + }, + { + "ROS": "CurlCli", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "end_date" + }, + { + "ROS": null, + "Terraform": "executed_by" + }, + { + "ROS": "ExecutionId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "is_parent" + }, + { + "ROS": "Outputs", + "Terraform": "outputs" + }, + { + "ROS": "PowerShellCurlCli", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "ram_role" + }, + { + "ROS": null, + "Terraform": "start_date" + }, + { + "ROS": "Status", + "Terraform": "status" + }, + { + "ROS": "StatusMessage", + "Terraform": "status_message" + }, + { + "ROS": null, + "Terraform": "template_id" + }, + { + "ROS": null, + "Terraform": "update_date" + }, + { + "ROS": "WindowsCurlCli", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::OOS::Parameter", + "Terraform": "alicloud_oos_parameter" + }, + "ProductCode": "oos", + "Name": { + "zh": "OOS参数", + "en": "OOS Parameter" + }, + "Properties": [ + { + "ROS": "Constraints", + "Terraform": "constraints", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "Name", + "Terraform": "parameter_name", + "Required": true + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": "Type", + "Terraform": "type", + "Required": true + }, + { + "ROS": "Value", + "Terraform": "value", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "Name", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "Value", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::OOS::PatchBaseline", + "Terraform": "alicloud_oos_patch_baseline" + }, + "ProductCode": "oos", + "Name": { + "zh": "OOS补丁基线", + "en": "OOS Patch Baseline" + }, + "Properties": [ + { + "ROS": "ApprovalRules", + "Terraform": "approval_rules", + "Required": true + }, + { + "ROS": "ApprovedPatches", + "Terraform": "approved_patches", + "Required": false + }, + { + "ROS": "ApprovedPatchesEnableNonSecurity", + "Terraform": "approved_patches_enable_non_security", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "OperationSystem", + "Terraform": "operation_system", + "Required": true + }, + { + "ROS": "PatchBaselineName", + "Terraform": "patch_baseline_name", + "Required": true + }, + { + "ROS": "RejectedPatches", + "Terraform": "rejected_patches", + "Required": false + }, + { + "ROS": "RejectedPatchesAction", + "Terraform": "rejected_patches_action", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "Sources", + "Terraform": "sources", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "ApprovalRules", + "Terraform": null + }, + { + "ROS": "ApprovedPatches", + "Terraform": null + }, + { + "ROS": "ApprovedPatchesEnableNonSecurity", + "Terraform": null + }, + { + "ROS": "CreatedBy", + "Terraform": null + }, + { + "ROS": "CreateTime", + "Terraform": "create_time" + }, + { + "ROS": "Description", + "Terraform": null + }, + { + "ROS": "PatchBaselineName", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "IsDefault", + "Terraform": null + }, + { + "ROS": "OperationSystem", + "Terraform": null + }, + { + "ROS": "PatchBaselineId", + "Terraform": null + }, + { + "ROS": "RejectedPatches", + "Terraform": null + }, + { + "ROS": "RejectedPatchesAction", + "Terraform": null + }, + { + "ROS": "ResourceGroupId", + "Terraform": null + }, + { + "ROS": "ShareType", + "Terraform": null + }, + { + "ROS": "Sources", + "Terraform": null + }, + { + "ROS": "Tags", + "Terraform": null + }, + { + "ROS": "UpdatedBy", + "Terraform": null + }, + { + "ROS": "UpdatedDate", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::OOS::SecretParameter", + "Terraform": "alicloud_oos_secret_parameter" + }, + "ProductCode": "oos", + "Name": { + "zh": "OOS加密参数", + "en": "OOS Encryption Parameter" + }, + "Properties": [ + { + "ROS": "Constraints", + "Terraform": "constraints", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "KeyId", + "Terraform": "key_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::KMS::Key" + } + ] + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "SecretParameterName", + "Terraform": "secret_parameter_name", + "Required": true + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": null, + "Terraform": "type", + "Required": false + }, + { + "ROS": "Value", + "Terraform": "value", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "Constraints", + "Terraform": null + }, + { + "ROS": "CreatedBy", + "Terraform": null + }, + { + "ROS": "CreateTime", + "Terraform": null + }, + { + "ROS": "Description", + "Terraform": null + }, + { + "ROS": "SecretParameterName", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "KeyId", + "Terraform": null + }, + { + "ROS": "ParameterVersion", + "Terraform": null + }, + { + "ROS": "ResourceGroupId", + "Terraform": null + }, + { + "ROS": "SecretParameterId", + "Terraform": null + }, + { + "ROS": "ShareType", + "Terraform": null + }, + { + "ROS": "Tags", + "Terraform": null + }, + { + "ROS": "Type", + "Terraform": null + }, + { + "ROS": "UpdatedBy", + "Terraform": null + }, + { + "ROS": "UpdatedDate", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::OOS::ServiceSettings", + "Terraform": null + }, + "ProductCode": "oos", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "DeliveryOssBucketName", + "Terraform": null, + "Required": false + }, + { + "ROS": "DeliveryOssEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "DeliveryOssKeyPrefix", + "Terraform": null, + "Required": false + }, + { + "ROS": "DeliverySlsEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "DeliverySlsProjectName", + "Terraform": null, + "Required": false + }, + { + "ROS": "RdcEnterpriseId", + "Terraform": null, + "Required": false + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::OOS::StateConfiguration", + "Terraform": "alicloud_oos_state_configuration" + }, + "ProductCode": "oos", + "Name": { + "zh": "OOS StateConfiguration", + "en": "OOS Desired-state Configuration" + }, + "Properties": [ + { + "ROS": "ConfigureMode", + "Terraform": "configure_mode", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "Parameters", + "Terraform": "parameters", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "ScheduleExpression", + "Terraform": "schedule_expression", + "Required": true + }, + { + "ROS": "ScheduleType", + "Terraform": "schedule_type", + "Required": true + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "Targets", + "Terraform": "targets", + "Required": true + }, + { + "ROS": "TemplateName", + "Terraform": "template_name", + "Required": true + }, + { + "ROS": "TemplateVersion", + "Terraform": "template_version", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "StateConfigurationId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::OOS::Template", + "Terraform": "alicloud_oos_template" + }, + "ProductCode": "oos", + "Name": { + "zh": "OOS模板", + "en": "OOS Template" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "auto_delete_executions", + "Required": false + }, + { + "ROS": "Content", + "Terraform": "content", + "Required": true + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "TemplateName", + "Terraform": "template_name", + "Required": true + }, + { + "ROS": null, + "Terraform": "version_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "created_by" + }, + { + "ROS": null, + "Terraform": "created_date" + }, + { + "ROS": null, + "Terraform": "description" + }, + { + "ROS": "ExecutionPolicy", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "has_trigger" + }, + { + "ROS": "TemplateName", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "share_type" + }, + { + "ROS": null, + "Terraform": "template_format" + }, + { + "ROS": "TemplateId", + "Terraform": "template_id" + }, + { + "ROS": null, + "Terraform": "template_type" + }, + { + "ROS": null, + "Terraform": "template_version" + }, + { + "ROS": null, + "Terraform": "updated_by" + }, + { + "ROS": null, + "Terraform": "updated_date" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_oos_application" + }, + "ProductCode": "oos", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "application_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_oos_application_group" + }, + "ProductCode": "oos", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "application_group_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "application_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "deploy_region_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "import_tag_key", + "Required": false + }, + { + "ROS": null, + "Terraform": "import_tag_value", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_oos_service_setting" + }, + "ProductCode": "oos", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "delivery_oss_bucket_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "delivery_oss_enabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "delivery_oss_key_prefix", + "Required": false + }, + { + "ROS": null, + "Terraform": "delivery_sls_enabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "delivery_sls_project_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SLS::Alert", + "Terraform": "alicloud_log_alert" + }, + "ProductCode": "sls", + "Name": { + "zh": "SLS告警", + "en": "SLS Alert" + }, + "Properties": [ + { + "ROS": "Detail.Description", + "Terraform": "alert_description", + "Required": false + }, + { + "ROS": "Detail.DisplayName", + "Terraform": "alert_displayname", + "Required": false + }, + { + "ROS": "Detail.Name", + "Terraform": "alert_name", + "Required": false + }, + { + "ROS": "Detail.Configuration.Annotations", + "Terraform": "annotations", + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": "key", + "Required": false + }, + { + "ROS": "Value", + "Terraform": "value", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "Detail.Configuration.AutoAnnotation", + "Terraform": "auto_annotation", + "Required": false + }, + { + "ROS": null, + "Terraform": "configuration", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "display_name", + "Required": false + }, + { + "ROS": "Detail.Configuration.GroupConfiguration", + "Terraform": "group_configuration", + "Required": false, + "Properties": [ + { + "ROS": "Fields", + "Terraform": "fields", + "Required": false + }, + { + "ROS": "Type", + "Terraform": "type", + "Required": false + } + ] + }, + { + "ROS": "Detail.Configuration.JoinConfigurations", + "Terraform": "join_configurations", + "Required": false, + "Properties": [ + { + "ROS": "Condition", + "Terraform": "condition", + "Required": false + }, + { + "ROS": "Type", + "Terraform": "type", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "Detail.Configuration.Labels", + "Terraform": "labels", + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": "key", + "Required": false + }, + { + "ROS": "Value", + "Terraform": "value", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "Detail.Configuration.MuteUntil", + "Terraform": "mute_until", + "Required": false + }, + { + "ROS": "Detail.Configuration.NoDataFire", + "Terraform": "no_data_fire", + "Required": false + }, + { + "ROS": "Detail.Configuration.NoDataSeverity", + "Terraform": "no_data_severity", + "Required": false + }, + { + "ROS": "Detail.Configuration.PolicyConfiguration", + "Terraform": "policy_configuration", + "Required": false, + "Properties": [ + { + "ROS": "ActionPolicyId", + "Terraform": "action_policy_id", + "Required": false + }, + { + "ROS": "AlertPolicyId", + "Terraform": "alert_policy_id", + "Required": false + }, + { + "ROS": "RepeatInterval", + "Terraform": "repeat_interval", + "Required": false + }, + { + "ROS": "UseDefault", + "Terraform": "use_default", + "Required": false + } + ] + }, + { + "ROS": "Project", + "Terraform": "project_name", + "Required": true + }, + { + "ROS": "Detail.Configuration.Schedule", + "Terraform": "schedule", + "Required": false, + "Properties": [ + { + "ROS": "CronExpression", + "Terraform": "cron_expression", + "Required": false + }, + { + "ROS": "DayOfWeek", + "Terraform": "day_of_week", + "Required": false + }, + { + "ROS": "Delay", + "Terraform": "delay", + "Required": false + }, + { + "ROS": "Hour", + "Terraform": "hour", + "Required": false + }, + { + "ROS": "Interval", + "Terraform": "interval", + "Required": false + }, + { + "ROS": "RunImmediately", + "Terraform": "run_immediately", + "Required": false + }, + { + "ROS": "Type", + "Terraform": "type", + "Required": false + } + ] + }, + { + "ROS": "Detail.Configuration.SendResolved", + "Terraform": "send_resolved", + "Required": false + }, + { + "ROS": "Detail.Configuration.SeverityConfigurations", + "Terraform": "severity_configurations", + "Required": false, + "Properties": [ + { + "ROS": "EvalCondition", + "Terraform": "eval_condition", + "Required": false + }, + { + "ROS": "Severity", + "Terraform": "severity", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": null, + "Terraform": "template_configuration", + "Required": false + }, + { + "ROS": "Detail.Configuration.Threshold", + "Terraform": "threshold", + "Required": false + }, + { + "ROS": "Detail.Type", + "Terraform": "type", + "Required": false + }, + { + "ROS": "Detail.Configuration.Version", + "Terraform": "version", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "Name", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SLS::ApplyConfigToMachineGroup", + "Terraform": null + }, + "ProductCode": "sls", + "Name": { + "zh": "日志配置应用于机器组", + "en": "Apply Log Configuration to Machine Group" + }, + "Properties": [ + { + "ROS": "ConfigName", + "Terraform": null, + "Required": false + }, + { + "ROS": "GroupName", + "Terraform": null, + "Required": false + }, + { + "ROS": "ProjectName", + "Terraform": null, + "Required": false + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SLS::Audit", + "Terraform": "alicloud_log_audit" + }, + "ProductCode": "sls", + "Name": { + "zh": "日志审计", + "en": "Log Audit Service" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "aliuid", + "Required": false + }, + { + "ROS": "DisplayName", + "Terraform": "display_name", + "Required": true + }, + { + "ROS": "MultiAccount", + "Terraform": "multi_account", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_directory_type", + "Required": false + }, + { + "ROS": "VariableMap", + "Terraform": "variable_map", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "DisplayName", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SLS::ConsumerGroup", + "Terraform": null + }, + "ProductCode": "sls", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "ConsumerGroup", + "Terraform": null, + "Required": true + }, + { + "ROS": "Logstore", + "Terraform": null, + "Required": true + }, + { + "ROS": "Order", + "Terraform": null, + "Required": true + }, + { + "ROS": "Project", + "Terraform": null, + "Required": true + }, + { + "ROS": "Timeout", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "ConsumerGroup", + "Terraform": null + }, + { + "ROS": "Logstore", + "Terraform": null + }, + { + "ROS": "Project", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SLS::Dashboard", + "Terraform": "alicloud_log_dashboard" + }, + "ProductCode": "sls", + "Name": { + "zh": "SLS仪表盘", + "en": "SLS Dashboard" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "attribute", + "Required": false + }, + { + "ROS": null, + "Terraform": "char_list", + "Required": false + }, + { + "ROS": "Charts", + "Terraform": null, + "Required": true, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "DashboardName", + "Terraform": "dashboard_name", + "Required": true + }, + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "DisplayName", + "Terraform": "display_name", + "Required": false + }, + { + "ROS": "ProjectName", + "Terraform": "project_name", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "DisplayName", + "Terraform": null + }, + { + "ROS": "DashboardName", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SLS::Etl", + "Terraform": "alicloud_log_etl" + }, + "ProductCode": "sls", + "Name": { + "zh": "SLS数据加工", + "en": "SLS Data Transformation Task" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "access_key_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "access_key_secret", + "Required": false + }, + { + "ROS": null, + "Terraform": "create_time", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "DisplayName", + "Terraform": "display_name", + "Required": true + }, + { + "ROS": "Name", + "Terraform": "etl_name", + "Required": true + }, + { + "ROS": "Configuration.Sinks", + "Terraform": "etl_sinks", + "Required": true, + "Properties": [ + { + "ROS": null, + "Terraform": "access_key_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "access_key_secret", + "Required": false + }, + { + "ROS": "Endpoint", + "Terraform": "endpoint", + "Required": false + }, + { + "ROS": null, + "Terraform": "kms_encrypted_access_key_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "kms_encrypted_access_key_secret", + "Required": false + }, + { + "ROS": "Logstore", + "Terraform": "logstore", + "Required": true + }, + { + "ROS": "Name", + "Terraform": "name", + "Required": true + }, + { + "ROS": "Project", + "Terraform": "project", + "Required": true + }, + { + "ROS": "RoleArn", + "Terraform": "role_arn", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": null, + "Terraform": "etl_type", + "Required": false + }, + { + "ROS": "Configuration.FromTime", + "Terraform": "from_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "kms_encrypted_access_key_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "kms_encrypted_access_key_secret", + "Required": false + }, + { + "ROS": null, + "Terraform": "kms_encryption_access_key_id_context", + "Required": false + }, + { + "ROS": null, + "Terraform": "kms_encryption_access_key_secret_context", + "Required": false + }, + { + "ROS": null, + "Terraform": "last_modified_time", + "Required": false + }, + { + "ROS": "Configuration.Logstore", + "Terraform": "logstore", + "Required": false + }, + { + "ROS": "Configuration.Parameters", + "Terraform": "parameters", + "Required": false + }, + { + "ROS": "ProjectName", + "Terraform": "project", + "Required": true + }, + { + "ROS": "Configuration.RoleArn", + "Terraform": "role_arn", + "Required": false + }, + { + "ROS": "Schedule.Type", + "Terraform": "schedule", + "Required": true + }, + { + "ROS": "Configuration.Script", + "Terraform": "script", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": "Configuration.ToTime", + "Terraform": "to_time", + "Required": false + }, + { + "ROS": "Configuration.Version", + "Terraform": "version", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "Name", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SLS::Index", + "Terraform": "alicloud_log_store_index" + }, + "ProductCode": "sls", + "Name": { + "zh": "SLS索引", + "en": "SLS Index" + }, + "Properties": [ + { + "ROS": "KeyIndices", + "Terraform": "field_search", + "Required": false, + "Properties": [ + { + "ROS": "Alias", + "Terraform": "alias", + "Required": false + }, + { + "ROS": "CaseSensitive", + "Terraform": "case_sensitive", + "Required": false + }, + { + "ROS": "EnableAnalytics", + "Terraform": "enable_analytics", + "Required": false + }, + { + "ROS": "IncludeChinese", + "Terraform": "include_chinese", + "Required": false + }, + { + "ROS": "JsonKeyIndices", + "Terraform": "json_keys", + "Required": false + }, + { + "ROS": "Name", + "Terraform": "name", + "Required": true + }, + { + "ROS": null, + "Terraform": "token", + "Required": false + }, + { + "ROS": "Type", + "Terraform": "type", + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "FullTextIndex", + "Terraform": "full_text", + "Required": true, + "Properties": [ + { + "ROS": "CaseSensitive", + "Terraform": "case_sensitive", + "Required": false + }, + { + "ROS": "IncludeChinese", + "Terraform": "include_chinese", + "Required": false + }, + { + "ROS": null, + "Terraform": "token", + "Required": false + } + ] + }, + { + "ROS": "LogReduce", + "Terraform": null, + "Required": false + }, + { + "ROS": "LogstoreName", + "Terraform": "logstore", + "Required": true + }, + { + "ROS": "ProjectName", + "Terraform": "project", + "Required": true + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SLS::Logstore", + "Terraform": "alicloud_log_store" + }, + "ProductCode": "sls", + "Name": { + "zh": "SLS日志库", + "en": "SLS Logstore" + }, + "Properties": [ + { + "ROS": "AppendMeta", + "Terraform": "append_meta", + "Required": false + }, + { + "ROS": "AutoSplit", + "Terraform": "auto_split", + "Required": false + }, + { + "ROS": "EnableTracking", + "Terraform": "enable_web_tracking", + "Required": false + }, + { + "ROS": "EncryptConf", + "Terraform": "encrypt_conf", + "Required": false + }, + { + "ROS": null, + "Terraform": "hot_ttl", + "Required": false + }, + { + "ROS": null, + "Terraform": "infrequent_access_ttl", + "Required": false + }, + { + "ROS": "LogstoreName", + "Terraform": "logstore_name", + "Required": true + }, + { + "ROS": "MaxSplitShard", + "Terraform": "max_split_shard_count", + "Required": false + }, + { + "ROS": null, + "Terraform": "metering_mode", + "Required": false + }, + { + "ROS": "Mode", + "Terraform": "mode", + "Required": false + }, + { + "ROS": "PreserveStorage", + "Terraform": null, + "Required": false + }, + { + "ROS": "ProjectName", + "Terraform": "project_name", + "Required": true + }, + { + "ROS": "TTL", + "Terraform": "retention_period", + "Required": false + }, + { + "ROS": "ShardCount", + "Terraform": "shard_count", + "Required": false + }, + { + "ROS": null, + "Terraform": "telemetry_type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "LogstoreName", + "Terraform": null + }, + { + "ROS": "ProjectName", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "shards" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SLS::LogtailConfig", + "Terraform": "alicloud_logtail_config" + }, + "ProductCode": "sls", + "Name": { + "zh": "Logtail参数", + "en": "Logtail Parameters" + }, + "Properties": [ + { + "ROS": "CloneFrom", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "LogtailConfigName", + "Terraform": null, + "Required": true + }, + { + "ROS": "ProjectName", + "Terraform": null, + "Required": true + } + ] + }, + { + "ROS": null, + "Terraform": "input_detail", + "Required": false + }, + { + "ROS": null, + "Terraform": "input_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "last_modify_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "log_sample", + "Required": false + }, + { + "ROS": null, + "Terraform": "logstore", + "Required": false + }, + { + "ROS": "LogstoreName", + "Terraform": null, + "Required": true + }, + { + "ROS": "LogtailConfigName", + "Terraform": null, + "Required": true + }, + { + "ROS": null, + "Terraform": "name", + "Required": false + }, + { + "ROS": null, + "Terraform": "output_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "project", + "Required": false + }, + { + "ROS": "ProjectName", + "Terraform": null, + "Required": true + }, + { + "ROS": "RawConfigData", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "AppliedMachineGroups", + "Terraform": null + }, + { + "ROS": "Endpoint", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "LogtailConfigName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SLS::MachineGroup", + "Terraform": "alicloud_log_machine_group" + }, + "ProductCode": "sls", + "Name": { + "zh": "SLS机器组", + "en": "SLS Machine Group" + }, + "Properties": [ + { + "ROS": "GroupAttribute", + "Terraform": null, + "Required": false + }, + { + "ROS": "GroupType", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "identify_list", + "Required": false + }, + { + "ROS": "MachineIdentifyType", + "Terraform": "identify_type", + "Required": false + }, + { + "ROS": "MachineList", + "Terraform": null, + "Required": false + }, + { + "ROS": "GroupName", + "Terraform": "name", + "Required": false + }, + { + "ROS": "ProjectName", + "Terraform": "project", + "Required": false + }, + { + "ROS": null, + "Terraform": "topic", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "identify_list" + }, + { + "ROS": null, + "Terraform": "identify_type" + }, + { + "ROS": "GroupName", + "Terraform": "name" + }, + { + "ROS": "ProjectName", + "Terraform": "project" + }, + { + "ROS": null, + "Terraform": "topic" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SLS::MetricStore", + "Terraform": null + }, + "ProductCode": "sls", + "Name": { + "zh": "SLS日志库", + "en": "SLS Logstore" + }, + "Properties": [ + { + "ROS": "LogstoreName", + "Terraform": null, + "Required": true + }, + { + "ROS": "PreserveStorage", + "Terraform": null, + "Required": false + }, + { + "ROS": "ProjectName", + "Terraform": null, + "Required": true + }, + { + "ROS": "ShardCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "TTL", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "LogstoreName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SLS::OssExport", + "Terraform": "alicloud_log_oss_export" + }, + "ProductCode": "sls", + "Name": { + "zh": "SLS OssExport", + "en": "SLS OSS Export" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "bucket", + "Required": false + }, + { + "ROS": null, + "Terraform": "buffer_interval", + "Required": false + }, + { + "ROS": null, + "Terraform": "buffer_size", + "Required": false + }, + { + "ROS": null, + "Terraform": "compress_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "config_columns", + "Required": false + }, + { + "ROS": "Configuration", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "FromTime", + "Terraform": null, + "Required": false + }, + { + "ROS": "Logstore", + "Terraform": null, + "Required": true + }, + { + "ROS": "RoleArn", + "Terraform": null, + "Required": true + }, + { + "ROS": "Sink", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "Bucket", + "Terraform": null, + "Required": true + }, + { + "ROS": "BufferInterval", + "Terraform": null, + "Required": true + }, + { + "ROS": "BufferSize", + "Terraform": null, + "Required": true + }, + { + "ROS": "CompressionType", + "Terraform": null, + "Required": false + }, + { + "ROS": "ContentDetail", + "Terraform": null, + "Required": false + }, + { + "ROS": "ContentType", + "Terraform": null, + "Required": true + }, + { + "ROS": "DelaySeconds", + "Terraform": null, + "Required": false + }, + { + "ROS": "Endpoint", + "Terraform": null, + "Required": false + }, + { + "ROS": "PathFormat", + "Terraform": null, + "Required": false + }, + { + "ROS": "PathFormatType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Prefix", + "Terraform": null, + "Required": false + }, + { + "ROS": "RoleArn", + "Terraform": null, + "Required": true + }, + { + "ROS": "Suffix", + "Terraform": null, + "Required": false + }, + { + "ROS": "TimeZone", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "ToTime", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": null, + "Terraform": "content_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "csv_config_columns", + "Required": false + }, + { + "ROS": null, + "Terraform": "csv_config_delimiter", + "Required": false + }, + { + "ROS": null, + "Terraform": "csv_config_escape", + "Required": false + }, + { + "ROS": null, + "Terraform": "csv_config_header", + "Required": false + }, + { + "ROS": null, + "Terraform": "csv_config_linefeed", + "Required": false + }, + { + "ROS": null, + "Terraform": "csv_config_null", + "Required": false + }, + { + "ROS": null, + "Terraform": "csv_config_quote", + "Required": false + }, + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "DisplayName", + "Terraform": "display_name", + "Required": true + }, + { + "ROS": "ExportName", + "Terraform": "export_name", + "Required": true + }, + { + "ROS": null, + "Terraform": "from_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "json_enable_tag", + "Required": false + }, + { + "ROS": null, + "Terraform": "log_read_role_arn", + "Required": false + }, + { + "ROS": null, + "Terraform": "logstore_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "path_format", + "Required": false + }, + { + "ROS": null, + "Terraform": "prefix", + "Required": false + }, + { + "ROS": "ProjectName", + "Terraform": "project_name", + "Required": true + }, + { + "ROS": null, + "Terraform": "role_arn", + "Required": false + }, + { + "ROS": null, + "Terraform": "suffix", + "Required": false + }, + { + "ROS": null, + "Terraform": "time_zone", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "ExportName", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "ProjectName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SLS::OssExternalStore", + "Terraform": null + }, + "ProductCode": "sls", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "AccessId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::RAM::AccessKey" + } + ] + }, + { + "ROS": "AccessKey", + "Terraform": null, + "Required": true + }, + { + "ROS": "Bucket", + "Terraform": null, + "Required": true + }, + { + "ROS": "Columns", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "Type", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "Endpoint", + "Terraform": null, + "Required": true + }, + { + "ROS": "ExternalStoreName", + "Terraform": null, + "Required": true + }, + { + "ROS": "Objects", + "Terraform": null, + "Required": true, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "Project", + "Terraform": null, + "Required": true + }, + { + "ROS": "StoreType", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "ExternalStoreName", + "Terraform": null + }, + { + "ROS": "Project", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SLS::Project", + "Terraform": "alicloud_log_project" + }, + "ProductCode": "sls", + "Name": { + "zh": "SLS日志项目", + "en": "SLS Project" + }, + "Properties": [ + { + "ROS": "DataRedundancyType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": null, + "Terraform": "policy", + "Required": false + }, + { + "ROS": null, + "Terraform": "project_name", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "Name", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SLS::RdsExternalStore", + "Terraform": null + }, + "ProductCode": "sls", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "Db", + "Terraform": null, + "Required": true + }, + { + "ROS": "ExternalStoreName", + "Terraform": null, + "Required": true + }, + { + "ROS": "Host", + "Terraform": null, + "Required": true + }, + { + "ROS": "InstanceId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::RDS::DBInstance" + } + ] + }, + { + "ROS": "Password", + "Terraform": null, + "Required": true + }, + { + "ROS": "Port", + "Terraform": null, + "Required": true + }, + { + "ROS": "Project", + "Terraform": null, + "Required": true + }, + { + "ROS": "Region", + "Terraform": null, + "Required": true + }, + { + "ROS": "StoreType", + "Terraform": null, + "Required": true + }, + { + "ROS": "Table", + "Terraform": null, + "Required": true + }, + { + "ROS": "Username", + "Terraform": null, + "Required": true + }, + { + "ROS": "VpcId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ], + "Attributes": [ + { + "ROS": "ExternalStoreName", + "Terraform": null + }, + { + "ROS": "Project", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SLS::Savedsearch", + "Terraform": null + }, + "ProductCode": "sls", + "Name": { + "zh": "保存为快速查询", + "en": "Store as Saved Search" + }, + "Properties": [ + { + "ROS": "Detail", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "DisplayName", + "Terraform": null, + "Required": false + }, + { + "ROS": "Logstore", + "Terraform": null, + "Required": true + }, + { + "ROS": "SavedsearchName", + "Terraform": null, + "Required": true + }, + { + "ROS": "SearchQuery", + "Terraform": null, + "Required": true + }, + { + "ROS": "Topic", + "Terraform": null, + "Required": true + } + ] + }, + { + "ROS": "Project", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "SavedsearchName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SLS::ServiceLog", + "Terraform": null + }, + "ProductCode": "sls", + "Name": { + "zh": "SLS ServiceLog", + "en": "SLS Service Log" + }, + "Properties": [ + { + "ROS": "LogStorageLocation", + "Terraform": null, + "Required": true + }, + { + "ROS": "ProjectName", + "Terraform": null, + "Required": true + }, + { + "ROS": "ServiceLogTypes", + "Terraform": null, + "Required": true, + "Properties": {}, + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "ProjectName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_log_alert_resource" + }, + "ProductCode": "sls", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "lang", + "Required": false + }, + { + "ROS": null, + "Terraform": "project", + "Required": false + }, + { + "ROS": null, + "Terraform": "type", + "Required": false + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_sls_collection_policy" + }, + "ProductCode": "sls", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "centralize_config", + "Required": false + }, + { + "ROS": null, + "Terraform": "centralize_enabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "data_code", + "Required": false + }, + { + "ROS": null, + "Terraform": "data_config", + "Required": false + }, + { + "ROS": null, + "Terraform": "enabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "policy_config", + "Required": false + }, + { + "ROS": null, + "Terraform": "policy_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "product_code", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_directory", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "data_config" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_log_ingestion" + }, + "ProductCode": "sls", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "display_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "ingestion_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "interval", + "Required": false + }, + { + "ROS": null, + "Terraform": "logstore", + "Required": false + }, + { + "ROS": null, + "Terraform": "project", + "Required": false + }, + { + "ROS": null, + "Terraform": "run_immediately", + "Required": false + }, + { + "ROS": null, + "Terraform": "source", + "Required": false + }, + { + "ROS": null, + "Terraform": "time_zone", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_log_oss_shipper" + }, + "ProductCode": "sls", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "buffer_interval", + "Required": false + }, + { + "ROS": null, + "Terraform": "buffer_size", + "Required": false + }, + { + "ROS": null, + "Terraform": "compress_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "format", + "Required": false + }, + { + "ROS": null, + "Terraform": "logstore_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "oss_bucket", + "Required": false + }, + { + "ROS": null, + "Terraform": "oss_prefix", + "Required": false + }, + { + "ROS": null, + "Terraform": "path_format", + "Required": false + }, + { + "ROS": null, + "Terraform": "project_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "role_arn", + "Required": false + }, + { + "ROS": null, + "Terraform": "shipper_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_log_resource" + }, + "ProductCode": "sls", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "ext_info", + "Required": false + }, + { + "ROS": null, + "Terraform": "name", + "Required": false + }, + { + "ROS": null, + "Terraform": "schema", + "Required": false + }, + { + "ROS": null, + "Terraform": "type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_log_resource_record" + }, + "ProductCode": "sls", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "record_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "tag", + "Required": false + }, + { + "ROS": null, + "Terraform": "value", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_sls_scheduled_sql" + }, + "ProductCode": "sls", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "display_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "project", + "Required": false + }, + { + "ROS": null, + "Terraform": "schedule", + "Required": false + }, + { + "ROS": null, + "Terraform": "scheduled_sql_configuration", + "Required": false + }, + { + "ROS": null, + "Terraform": "scheduled_sql_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CR::Instance", + "Terraform": "alicloud_cr_ee_instance" + }, + "ProductCode": "acr", + "Name": { + "zh": "CR实例", + "en": "Container Registry Instance" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "custom_oss_bucket", + "Required": false + }, + { + "ROS": "ImageScanner", + "Terraform": null, + "Required": true + }, + { + "ROS": "InstanceName", + "Terraform": "instance_name", + "Required": true + }, + { + "ROS": "InstanceStorageName", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceType", + "Terraform": "instance_type", + "Required": true + }, + { + "ROS": null, + "Terraform": "kms_encrypted_password", + "Required": false + }, + { + "ROS": null, + "Terraform": "kms_encryption_context", + "Required": false + }, + { + "ROS": null, + "Terraform": "password", + "Required": false + }, + { + "ROS": null, + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": "Period", + "Terraform": "period", + "Required": true + }, + { + "ROS": "RenewalStatus", + "Terraform": "renewal_status", + "Required": false + }, + { + "ROS": "RenewPeriod", + "Terraform": "renew_period", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + } + ], + "Attributes": [ + { + "ROS": "CreateTime", + "Terraform": "created_time" + }, + { + "ROS": null, + "Terraform": "end_time" + }, + { + "ROS": "InstanceId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "InstanceName", + "Terraform": null + }, + { + "ROS": "InstanceSpecification", + "Terraform": null + }, + { + "ROS": "ModifiedTime", + "Terraform": null + }, + { + "ROS": "ResourceGroupId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CR::InstanceEndpointAclPolicy", + "Terraform": "alicloud_cr_endpoint_acl_policy" + }, + "ProductCode": "acr", + "Name": { + "zh": "CR白名单策略", + "en": "Container Registry Whitelist Policy" + }, + "Properties": [ + { + "ROS": "Comment", + "Terraform": "description", + "Required": false + }, + { + "ROS": "EndpointType", + "Terraform": "endpoint_type", + "Required": false + }, + { + "ROS": "Entry", + "Terraform": "entry", + "Required": true + }, + { + "ROS": "InstanceId", + "Terraform": "instance_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CR::Instance" + } + ] + }, + { + "ROS": "ModuleName", + "Terraform": "module_name", + "Required": false + }, + { + "ROS": "RegionId", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Entry", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "InstanceId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CR::InstanceVpcEndpointLinkedVpc", + "Terraform": "alicloud_cr_vpc_endpoint_linked_vpc" + }, + "ProductCode": "acr", + "Name": { + "zh": "可访问VPC实例", + "en": "Access to VPC" + }, + "Properties": [ + { + "ROS": "EnableCreateDNSRecordInPvzt", + "Terraform": "enable_create_dns_record_in_pvzt", + "Required": false + }, + { + "ROS": "InstanceId", + "Terraform": "instance_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CR::Instance" + } + ] + }, + { + "ROS": "ModuleName", + "Terraform": "module_name", + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VswitchId", + "Terraform": "vswitch_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "InstanceId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "VpcId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VswitchId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CR::Namespace", + "Terraform": "alicloud_cr_ee_namespace" + }, + "ProductCode": "acr", + "Name": { + "zh": "CR命名空间", + "en": "Container Registry Namespace" + }, + "Properties": [ + { + "ROS": "AutoCreate", + "Terraform": "auto_create", + "Required": false + }, + { + "ROS": "DefaultVisibility", + "Terraform": "default_visibility", + "Required": false + }, + { + "ROS": "InstanceId", + "Terraform": "instance_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CR::Instance" + } + ] + }, + { + "ROS": "Namespace", + "Terraform": "name", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "NamespaceId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "InstanceId", + "Terraform": null + }, + { + "ROS": "Namespace", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CR::Repository", + "Terraform": "alicloud_cr_ee_repo" + }, + "ProductCode": "acr", + "Name": { + "zh": "CR镜像仓库", + "en": "Container Registry Image Repository" + }, + "Properties": [ + { + "ROS": "Detail", + "Terraform": "detail", + "Required": false + }, + { + "ROS": null, + "Terraform": "domain_list", + "Required": false + }, + { + "ROS": "InstanceId", + "Terraform": "instance_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CR::Instance" + } + ] + }, + { + "ROS": "RepoName", + "Terraform": "name", + "Required": true + }, + { + "ROS": "RepoNamespace", + "Terraform": "namespace", + "Required": true + }, + { + "ROS": "RepoSource", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "IsAutoBuild", + "Terraform": null, + "Required": true + }, + { + "ROS": "IsDisableCache", + "Terraform": null, + "Required": true + }, + { + "ROS": "IsOversea", + "Terraform": null, + "Required": true + }, + { + "ROS": "SourceRepoName", + "Terraform": null, + "Required": true + }, + { + "ROS": "SourceRepoNamespace", + "Terraform": null, + "Required": true + }, + { + "ROS": "SourceRepoType", + "Terraform": null, + "Required": true + } + ] + }, + { + "ROS": "RepoType", + "Terraform": "repo_type", + "Required": true + }, + { + "ROS": "Summary", + "Terraform": "summary", + "Required": true + }, + { + "ROS": "TagImmutability", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "RepoId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "InstanceId", + "Terraform": null + }, + { + "ROS": "RepoId", + "Terraform": "repo_id" + }, + { + "ROS": "RepoName", + "Terraform": null + }, + { + "ROS": "RepoNamespace", + "Terraform": null + }, + { + "ROS": "RepoType", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CR::UserInfo", + "Terraform": null + }, + "ProductCode": "acr", + "Name": { + "zh": "CR用户信息", + "en": "Container Registry User Information" + }, + "Properties": [ + { + "ROS": "InstanceId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CR::Instance" + } + ] + }, + { + "ROS": "User", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "Password", + "Terraform": null, + "Required": true + } + ] + } + ], + "Attributes": [ + { + "ROS": "LoginName", + "Terraform": null + }, + { + "ROS": "UserId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cr_chain" + }, + "ProductCode": "acr", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "chain_config", + "Required": false + }, + { + "ROS": null, + "Terraform": "chain_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "repo_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "repo_namespace_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "chain_id" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cr_chart_namespace" + }, + "ProductCode": "acr", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "auto_create_repo", + "Required": false + }, + { + "ROS": null, + "Terraform": "default_repo_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "namespace_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cr_chart_repository" + }, + "ProductCode": "acr", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "repo_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "repo_namespace_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "repo_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "summary", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cr_ee_sync_rule" + }, + "ProductCode": "acr", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "name", + "Required": false + }, + { + "ROS": null, + "Terraform": "namespace_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "repo_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "tag_filter", + "Required": false + }, + { + "ROS": null, + "Terraform": "target_instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "target_namespace_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "target_region_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "target_repo_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "rule_id" + }, + { + "ROS": null, + "Terraform": "sync_direction" + }, + { + "ROS": null, + "Terraform": "sync_scope" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ADB::Account", + "Terraform": "alicloud_adb_account" + }, + "ProductCode": "adb", + "Name": { + "zh": "ADB账号", + "en": "AnalyticDB for MySQL Account" + }, + "Properties": [ + { + "ROS": "AccountDescription", + "Terraform": "account_description", + "Required": false + }, + { + "ROS": "AccountName", + "Terraform": "account_name", + "Required": true + }, + { + "ROS": "AccountPassword", + "Terraform": "account_password", + "Required": true + }, + { + "ROS": "AccountType", + "Terraform": "account_type", + "Required": false + }, + { + "ROS": "DBClusterId", + "Terraform": "db_cluster_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ADB::DBCluster" + } + ] + }, + { + "ROS": null, + "Terraform": "kms_encrypted_password", + "Required": false + }, + { + "ROS": null, + "Terraform": "kms_encryption_context", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "AccountName", + "Terraform": null + }, + { + "ROS": "AccountType", + "Terraform": null + }, + { + "ROS": "DBClusterId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ADB::DBCluster", + "Terraform": "alicloud_adb_db_cluster" + }, + "ProductCode": "adb", + "Name": { + "zh": "AnalyticDB MySQL版集群", + "en": "AnalyticDB for MySQL Cluster" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "auto_renew_period", + "Required": false + }, + { + "ROS": "ComputeResource", + "Terraform": "compute_resource", + "Required": false + }, + { + "ROS": "DBClusterCategory", + "Terraform": "db_cluster_category", + "Required": true + }, + { + "ROS": "DBClusterClass", + "Terraform": null, + "Required": false + }, + { + "ROS": "DBClusterVersion", + "Terraform": "db_cluster_version", + "Required": true + }, + { + "ROS": null, + "Terraform": "db_node_class", + "Required": false + }, + { + "ROS": "DBNodeGroupCount", + "Terraform": "db_node_count", + "Required": false + }, + { + "ROS": "DBNodeStorage", + "Terraform": "db_node_storage", + "Required": false + }, + { + "ROS": "DBClusterDescription", + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "disk_encryption", + "Required": false + }, + { + "ROS": null, + "Terraform": "disk_performance_level", + "Required": false + }, + { + "ROS": "ElasticIOResource", + "Terraform": "elastic_io_resource", + "Required": false + }, + { + "ROS": null, + "Terraform": "elastic_io_resource_size", + "Required": false + }, + { + "ROS": null, + "Terraform": "enable_ssl", + "Required": false + }, + { + "ROS": "ExecutorCount", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "kms_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "maintain_time", + "Required": false + }, + { + "ROS": "Mode", + "Terraform": "mode", + "Required": true + }, + { + "ROS": null, + "Terraform": "modify_type", + "Required": false + }, + { + "ROS": "PayType", + "Terraform": "payment_type", + "Required": true + }, + { + "ROS": "Period", + "Terraform": "period", + "Required": false + }, + { + "ROS": "PeriodType", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "renewal_status", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "security_ips", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "VPCId", + "Terraform": "vpc_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "ZoneId", + "Terraform": "zone_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": "ConnectionString", + "Terraform": "connection_string" + }, + { + "ROS": "DBClusterId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "OrderId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "port" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_adb_backup_policy" + }, + "ProductCode": "adb", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "db_cluster_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "preferred_backup_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "preferred_backup_time", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "backup_retention_period" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_adb_connection" + }, + "ProductCode": "adb", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "connection_prefix", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_cluster_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "connection_string" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "ip_address" + }, + { + "ROS": null, + "Terraform": "port" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_adb_lake_account" + }, + "ProductCode": "adb", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "account_description", + "Required": false + }, + { + "ROS": null, + "Terraform": "account_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "account_password", + "Required": false + }, + { + "ROS": null, + "Terraform": "account_privileges", + "Required": false + }, + { + "ROS": null, + "Terraform": "account_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_cluster_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_adb_resource_group" + }, + "ProductCode": "adb", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "db_cluster_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "group_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "group_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "node_num", + "Required": false + }, + { + "ROS": null, + "Terraform": "users", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "update_time" + }, + { + "ROS": null, + "Terraform": "user" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ACM::Configuration", + "Terraform": null + }, + "ProductCode": "acms", + "Name": { + "zh": "ACM配置", + "en": "Application Configuration Management Configuration" + }, + "Properties": [ + { + "ROS": "AppName", + "Terraform": null, + "Required": false + }, + { + "ROS": "Content", + "Terraform": null, + "Required": true + }, + { + "ROS": "DataId", + "Terraform": null, + "Required": true + }, + { + "ROS": "Desc", + "Terraform": null, + "Required": false + }, + { + "ROS": "Group", + "Terraform": null, + "Required": false + }, + { + "ROS": "NamespaceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ACM::Namespace" + } + ] + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false + }, + { + "ROS": "Type", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "DataId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "Group", + "Terraform": null + }, + { + "ROS": "NamespaceId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ACM::Namespace", + "Terraform": null + }, + "ProductCode": "acms", + "Name": { + "zh": "ACM命名空间", + "en": "Application Configuration Management Namespace" + }, + "Properties": [ + { + "ROS": "Name", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "Endpoint", + "Terraform": null + }, + { + "ROS": "NamespaceId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ACS::Cluster", + "Terraform": null + }, + "ProductCode": "acs", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "Addons", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Config", + "Terraform": null, + "Required": false + }, + { + "ROS": "Disabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "ClusterSpec", + "Terraform": null, + "Required": false + }, + { + "ROS": "DeletionProtection", + "Terraform": null, + "Required": false + }, + { + "ROS": "EndpointPublicAccess", + "Terraform": null, + "Required": false + }, + { + "ROS": "IpStack", + "Terraform": null, + "Required": false + }, + { + "ROS": "KubernetesVersion", + "Terraform": null, + "Required": false + }, + { + "ROS": "LoadBalancerSpec", + "Terraform": null, + "Required": false + }, + { + "ROS": "LoggingType", + "Terraform": null, + "Required": false + }, + { + "ROS": "MaintenanceWindow", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Duration", + "Terraform": null, + "Required": false + }, + { + "ROS": "Enable", + "Terraform": null, + "Required": false + }, + { + "ROS": "MaintenanceTime", + "Terraform": null, + "Required": false + }, + { + "ROS": "WeeklyPeriod", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "PodVSwitchIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "ServiceCidr", + "Terraform": null, + "Required": false + }, + { + "ROS": "ServiceDiscoveryTypes", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "SlsProjectName", + "Terraform": null, + "Required": false + }, + { + "ROS": "SnatEntry", + "Terraform": null, + "Required": false + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "TimeZone", + "Terraform": null, + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ], + "Type": "list" + }, + { + "ROS": "ZoneIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "APIServerSLBId", + "Terraform": null + }, + { + "ROS": "ClusterId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "DefaultUserKubeConfig", + "Terraform": null + }, + { + "ROS": "IngressSLBId", + "Terraform": null + }, + { + "ROS": "Nodes", + "Terraform": null + }, + { + "ROS": "PrivateUserKubConfig", + "Terraform": null + }, + { + "ROS": "ScalingConfigurationId", + "Terraform": null + }, + { + "ROS": "ScalingGroupId", + "Terraform": null + }, + { + "ROS": "ScalingRuleId", + "Terraform": null + }, + { + "ROS": "TaskId", + "Terraform": null + }, + { + "ROS": "WorkerRamRoleName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ACTIONTRAIL::Trail", + "Terraform": "alicloud_actiontrail_trail" + }, + "ProductCode": "actiontrail", + "Name": { + "zh": "ACTIONTRAIL 跟踪", + "en": "ActionTrail Trail" + }, + "Properties": [ + { + "ROS": "EventRW", + "Terraform": "event_rw", + "Required": false + }, + { + "ROS": null, + "Terraform": "is_organization_trail", + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "OssBucketName", + "Terraform": "oss_bucket_name", + "Required": false + }, + { + "ROS": "OssKeyPrefix", + "Terraform": "oss_key_prefix", + "Required": false + }, + { + "ROS": null, + "Terraform": "oss_write_role_arn", + "Required": false + }, + { + "ROS": "RoleName", + "Terraform": null, + "Required": false + }, + { + "ROS": "SlsProjectArn", + "Terraform": "sls_project_arn", + "Required": false + }, + { + "ROS": "SlsWriteRoleArn", + "Terraform": "sls_write_role_arn", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": null, + "Terraform": "trail_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "trail_region", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Name", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ACTIONTRAIL::TrailLogging", + "Terraform": null + }, + "ProductCode": "actiontrail", + "Name": { + "zh": "ACTIONTRAIL 跟踪日志记录", + "en": "ActionTrail Trail Logging" + }, + "Properties": [ + { + "ROS": "Enable", + "Terraform": null, + "Required": true + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ACTIONTRAIL::Trail" + } + ] + } + ], + "Attributes": [ + { + "ROS": "IsLogging", + "Terraform": null + }, + { + "ROS": "LatestDeliveryError", + "Terraform": null + }, + { + "ROS": "LatestDeliveryTime", + "Terraform": null + }, + { + "ROS": "StartLoggingTime", + "Terraform": null + }, + { + "ROS": "StopLoggingTime", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ADBLake::Account", + "Terraform": null + }, + "ProductCode": "openanalytics", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "AccountDescription", + "Terraform": null, + "Required": false + }, + { + "ROS": "AccountName", + "Terraform": null, + "Required": true + }, + { + "ROS": "AccountPassword", + "Terraform": null, + "Required": true + }, + { + "ROS": "AccountType", + "Terraform": null, + "Required": true + }, + { + "ROS": "DBClusterId", + "Terraform": null, + "Required": true + }, + { + "ROS": "Engine", + "Terraform": null, + "Required": true + }, + { + "ROS": "RamUser", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "AccountName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ADBLake::DBCluster", + "Terraform": "alicloud_adb_db_cluster_lake_version" + }, + "ProductCode": "openanalytics", + "Name": { + "zh": "ADBLake DBCluster", + "en": "AnalyticDB for MySQL Cluster" + }, + "Properties": [ + { + "ROS": "BackupSetId", + "Terraform": "backup_set_id", + "Required": false + }, + { + "ROS": "CloneSourceRegionId", + "Terraform": null, + "Required": false + }, + { + "ROS": "ComputeResource", + "Terraform": "compute_resource", + "Required": true + }, + { + "ROS": "DBClusterDescription", + "Terraform": "db_cluster_description", + "Required": false + }, + { + "ROS": "DBClusterNetworkType", + "Terraform": null, + "Required": false + }, + { + "ROS": "DBClusterVersion", + "Terraform": "db_cluster_version", + "Required": false + }, + { + "ROS": "DiskEncryption", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "enable_default_resource_group", + "Required": false + }, + { + "ROS": "EnableDefaultResourcePool", + "Terraform": null, + "Required": false + }, + { + "ROS": "KmsId", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": "PayType", + "Terraform": null, + "Required": true + }, + { + "ROS": "Period", + "Terraform": null, + "Required": false + }, + { + "ROS": "PeriodType", + "Terraform": null, + "Required": false + }, + { + "ROS": "ProductForm", + "Terraform": null, + "Required": false + }, + { + "ROS": "ReservedNodeCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "ReservedNodeSize", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "RestoreToTime", + "Terraform": "restore_to_time", + "Required": false + }, + { + "ROS": "RestoreType", + "Terraform": "restore_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "security_ips", + "Required": false + }, + { + "ROS": "SourceDbClusterId", + "Terraform": "source_db_cluster_id", + "Required": false + }, + { + "ROS": "StorageResource", + "Terraform": "storage_resource", + "Required": true + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "VPCId", + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "ZoneId", + "Terraform": "zone_id", + "Required": true + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "commodity_code" + }, + { + "ROS": "ConnectionString", + "Terraform": "connection_string" + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "engine" + }, + { + "ROS": null, + "Terraform": "engine_version" + }, + { + "ROS": null, + "Terraform": "expired" + }, + { + "ROS": null, + "Terraform": "expire_time" + }, + { + "ROS": "DBClusterId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "lock_mode" + }, + { + "ROS": null, + "Terraform": "lock_reason" + }, + { + "ROS": "OrderId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "port" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ADBLake::ResourceGroup", + "Terraform": null + }, + "ProductCode": "openanalytics", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "AutoStopInterval", + "Terraform": null, + "Required": false + }, + { + "ROS": "ClusterMode", + "Terraform": null, + "Required": false + }, + { + "ROS": "ClusterSizeResource", + "Terraform": null, + "Required": false + }, + { + "ROS": "DBClusterId", + "Terraform": null, + "Required": true + }, + { + "ROS": "EnableSpot", + "Terraform": null, + "Required": false + }, + { + "ROS": "Engine", + "Terraform": null, + "Required": true + }, + { + "ROS": "EngineParams", + "Terraform": null, + "Required": false + }, + { + "ROS": "GroupName", + "Terraform": null, + "Required": true + }, + { + "ROS": "GroupType", + "Terraform": null, + "Required": true + }, + { + "ROS": "MaxClusterCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "MaxComputeResource", + "Terraform": null, + "Required": false + }, + { + "ROS": "MinClusterCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "MinComputeResource", + "Terraform": null, + "Required": false + }, + { + "ROS": "Rules", + "Terraform": null, + "Required": false, + "Type": "list", + "Properties": [ + { + "ROS": "GroupName", + "Terraform": null, + "Required": true + }, + { + "ROS": "QueryTime", + "Terraform": null, + "Required": true + }, + { + "ROS": "TargetGroupName", + "Terraform": null, + "Required": true + } + ] + } + ], + "Attributes": [ + { + "ROS": "GroupName", + "Terraform": null + }, + { + "ROS": "GroupType", + "Terraform": null + }, + { + "ROS": "GroupUsers", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ADBLake::ResourceGroupAccountBinding", + "Terraform": null + }, + "ProductCode": "openanalytics", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "AccountName", + "Terraform": null, + "Required": true + }, + { + "ROS": "DBClusterId", + "Terraform": null, + "Required": true + }, + { + "ROS": "GroupName", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "GroupName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ALB::AScript", + "Terraform": "alicloud_alb_ascript" + }, + "ProductCode": "alb", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "AScriptName", + "Terraform": "ascript_name", + "Required": false + }, + { + "ROS": "Enabled", + "Terraform": "enabled", + "Required": false + }, + { + "ROS": "ExtAttributeEnabled", + "Terraform": "ext_attribute_enabled", + "Required": false + }, + { + "ROS": "ExtAttributes", + "Terraform": "ext_attributes", + "Required": false, + "Properties": [ + { + "ROS": "AttributeKey", + "Terraform": "attribute_key", + "Required": false + }, + { + "ROS": "AttributeValue", + "Terraform": "attribute_value", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "ListenerId", + "Terraform": "listener_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ALB::Listener" + } + ] + }, + { + "ROS": null, + "Terraform": "position", + "Required": false + }, + { + "ROS": "ScriptContent", + "Terraform": "script_content", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "AScriptId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "load_balancer_id" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ALB::Acl", + "Terraform": "alicloud_alb_acl" + }, + "ProductCode": "alb", + "Name": { + "zh": "ALB访问控制策略组", + "en": "ALB ACL" + }, + "Properties": [ + { + "ROS": "AclEntries", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "Entry", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "AclName", + "Terraform": "acl_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "AclId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ALB::AclAssociation", + "Terraform": "alicloud_alb_listener_acl_attachment" + }, + "MainResourceType": { + "ResourceType": "ROS/ALIYUN::ALB::Acl", + "RefProperty": "ROS/AclId" + }, + "ProductCode": "alb", + "Name": { + "zh": "ALB关联ACL到监听", + "en": "Associate ALB ACL with Listener" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "acl_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ALB::Acl" + } + ] + }, + { + "ROS": "AclIds", + "Terraform": null, + "Required": true, + "Properties": {}, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ALB::Acl" + } + ], + "Type": "list" + }, + { + "ROS": "AclType", + "Terraform": "acl_type", + "Required": true + }, + { + "ROS": "ListenerId", + "Terraform": "listener_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ALB::Listener" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "ListenerId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ALB::AdditionalCertificateAssociation", + "Terraform": "alicloud_alb_listener_additional_certificate_attachment" + }, + "ProductCode": "alb", + "Name": { + "zh": "扩展证书关联到监听", + "en": "Add Additional Certificates to Listener" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "certificate_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CAS::Certificate" + } + ] + }, + { + "ROS": "Certificates", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CAS::Certificate" + } + ], + "Properties": [ + { + "ROS": "CertificateId", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "ListenerId", + "Terraform": "listener_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ALB::Listener" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "certificate_type" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "ListenerId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ALB::BackendServerAttachment", + "Terraform": null + }, + "ProductCode": "alb", + "Name": { + "zh": "ALB添加后端服务器", + "en": "Attach ALB Backend Server" + }, + "Properties": [ + { + "ROS": "ServerGroupId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ALB::ServerGroup" + } + ] + }, + { + "ROS": "Servers", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "Port", + "Terraform": null, + "Required": false + }, + { + "ROS": "RemoteIpEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "ServerId", + "Terraform": null, + "Required": true + }, + { + "ROS": "ServerIp", + "Terraform": null, + "Required": false + }, + { + "ROS": "ServerType", + "Terraform": null, + "Required": true + }, + { + "ROS": "Weight", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "ServerGroupId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ALB::HealthCheckTemplate", + "Terraform": "alicloud_alb_health_check_template" + }, + "ProductCode": "alb", + "Name": { + "zh": "ALB健康检查模板", + "en": "ALB Health Check Template" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": "HealthCheckCodes", + "Terraform": "health_check_codes", + "Required": false + }, + { + "ROS": "HealthCheckConnectPort", + "Terraform": "health_check_connect_port", + "Required": false + }, + { + "ROS": "HealthCheckHost", + "Terraform": "health_check_host", + "Required": false + }, + { + "ROS": null, + "Terraform": "health_check_http_version", + "Required": false + }, + { + "ROS": "HealthCheckInterval", + "Terraform": "health_check_interval", + "Required": false + }, + { + "ROS": "HealthCheckMethod", + "Terraform": "health_check_method", + "Required": false + }, + { + "ROS": "HealthCheckPath", + "Terraform": "health_check_path", + "Required": false + }, + { + "ROS": "HealthCheckProtocol", + "Terraform": "health_check_protocol", + "Required": false + }, + { + "ROS": "HealthCheckTemplateName", + "Terraform": "health_check_template_name", + "Required": true + }, + { + "ROS": "HealthCheckTimeout", + "Terraform": "health_check_timeout", + "Required": false + }, + { + "ROS": "HealthyThreshold", + "Terraform": "healthy_threshold", + "Required": false + }, + { + "ROS": "UnhealthyThreshold", + "Terraform": "unhealthy_threshold", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "HealthCheckTemplateId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ALB::Listener", + "Terraform": "alicloud_alb_listener" + }, + "ProductCode": "alb", + "Name": { + "zh": "ALB监听", + "en": "ALB Listener" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "access_log_record_customized_headers_enabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "access_log_tracing_config", + "Required": false + }, + { + "ROS": "CaCertificates", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "CertificateId", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "CaEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "Certificates", + "Terraform": "certificates", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CAS::Certificate" + } + ], + "Properties": [ + { + "ROS": "CertificateId", + "Terraform": "certificate_id", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "DefaultActions", + "Terraform": "default_actions", + "Required": true, + "Properties": [ + { + "ROS": "ForwardGroupConfig", + "Terraform": "forward_group_config", + "Required": true + }, + { + "ROS": "Type", + "Terraform": "type", + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": "GzipEnabled", + "Terraform": "gzip_enabled", + "Required": false + }, + { + "ROS": "Http2Enabled", + "Terraform": "http2_enabled", + "Required": false + }, + { + "ROS": "IdleTimeout", + "Terraform": "idle_timeout", + "Required": false + }, + { + "ROS": "ListenerDescription", + "Terraform": "listener_description", + "Required": false + }, + { + "ROS": "ListenerPort", + "Terraform": "listener_port", + "Required": true + }, + { + "ROS": "ListenerProtocol", + "Terraform": "listener_protocol", + "Required": true + }, + { + "ROS": "ListenerStatus", + "Terraform": null, + "Required": false + }, + { + "ROS": "LoadBalancerId", + "Terraform": "load_balancer_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ALB::LoadBalancer" + } + ] + }, + { + "ROS": "LogConfig", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "AccessLogRecordCustomizedHeadersEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "AccessLogTracingConfig", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "TracingEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "TracingSample", + "Terraform": null, + "Required": false + }, + { + "ROS": "TracingType", + "Terraform": null, + "Required": false + } + ] + } + ] + }, + { + "ROS": "QuicConfig", + "Terraform": "quic_config", + "Required": false + }, + { + "ROS": "RequestTimeout", + "Terraform": "request_timeout", + "Required": false + }, + { + "ROS": "SecurityPolicyId", + "Terraform": "security_policy_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ALB::SecurityPolicy" + } + ] + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": "XForwardedForConfig", + "Terraform": "x_forwarded_for_config", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "ListenerId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "LoadBalancerId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ALB::LoadBalancer", + "Terraform": "alicloud_alb_load_balancer" + }, + "ProductCode": "alb", + "Name": { + "zh": "应用型负载均衡ALB", + "en": "ALB Instance" + }, + "Properties": [ + { + "ROS": "AccessLogConfig", + "Terraform": "access_log_config", + "Required": false, + "Properties": [ + { + "ROS": "LogProject", + "Terraform": "log_project", + "Required": true + }, + { + "ROS": "LogStore", + "Terraform": "log_store", + "Required": true + } + ] + }, + { + "ROS": "AddressAllocatedMode", + "Terraform": "address_allocated_mode", + "Required": false + }, + { + "ROS": "AddressIpVersion", + "Terraform": "address_ip_version", + "Required": false + }, + { + "ROS": "AddressType", + "Terraform": "address_type", + "Required": true + }, + { + "ROS": "BandwidthPackageId", + "Terraform": "bandwidth_package_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::CommonBandwidthPackage" + } + ] + }, + { + "ROS": "DeletionProtectionEnabled", + "Terraform": "deletion_protection_enabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": null, + "Terraform": "ipv6_address_type", + "Required": false + }, + { + "ROS": "LoadBalancerBillingConfig", + "Terraform": "load_balancer_billing_config", + "Required": true, + "Properties": [ + { + "ROS": "PayType", + "Terraform": "pay_type", + "Required": true + } + ] + }, + { + "ROS": "LoadBalancerEdition", + "Terraform": "load_balancer_edition", + "Required": true + }, + { + "ROS": "LoadBalancerName", + "Terraform": "load_balancer_name", + "Required": true + }, + { + "ROS": "ModificationProtectionConfig", + "Terraform": "modification_protection_config", + "Required": false, + "Properties": [ + { + "ROS": "Reason", + "Terraform": "reason", + "Required": false + }, + { + "ROS": "Status", + "Terraform": "status", + "Required": true + } + ] + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "SecurityGroupIds", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ], + "Properties": {}, + "Type": "list" + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "ZoneMappings", + "Terraform": "zone_mappings", + "Required": true, + "Properties": [ + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "ZoneId", + "Terraform": "zone_id", + "Required": true + } + ], + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "AddressType", + "Terraform": null + }, + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "DNSName", + "Terraform": "dns_name" + }, + { + "ROS": "LoadBalancerId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "LoadBalancerEdition", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "VpcId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "ZoneMappings", + "Terraform": "zone_mappings" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ALB::Rule", + "Terraform": "alicloud_alb_rule" + }, + "ProductCode": "alb", + "Name": { + "zh": "ALB转发规则", + "en": "ALB Forwarding Rule" + }, + "Properties": [ + { + "ROS": "Direction", + "Terraform": "direction", + "Required": false + }, + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": "ListenerId", + "Terraform": "listener_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ALB::Listener" + } + ] + }, + { + "ROS": "Priority", + "Terraform": "priority", + "Required": true + }, + { + "ROS": "RuleActions", + "Terraform": "rule_actions", + "Required": true, + "Properties": [ + { + "ROS": "CorsConfig", + "Terraform": "cors_config", + "Required": false + }, + { + "ROS": "FixedResponseConfig", + "Terraform": "fixed_response_config", + "Required": false + }, + { + "ROS": "ForwardGroupConfig", + "Terraform": "forward_group_config", + "Required": false + }, + { + "ROS": "InsertHeaderConfig", + "Terraform": "insert_header_config", + "Required": false + }, + { + "ROS": "Order", + "Terraform": "order", + "Required": true + }, + { + "ROS": "RedirectConfig", + "Terraform": "redirect_config", + "Required": false + }, + { + "ROS": "RemoveHeaderConfig", + "Terraform": "remove_header_config", + "Required": false + }, + { + "ROS": "RewriteConfig", + "Terraform": "rewrite_config", + "Required": false + }, + { + "ROS": "TrafficLimitConfig", + "Terraform": "traffic_limit_config", + "Required": false + }, + { + "ROS": "TrafficMirrorConfig", + "Terraform": "traffic_mirror_config", + "Required": false + }, + { + "ROS": "Type", + "Terraform": "type", + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "RuleConditions", + "Terraform": "rule_conditions", + "Required": true, + "Properties": [ + { + "ROS": "CookieConfig", + "Terraform": "cookie_config", + "Required": false + }, + { + "ROS": "HeaderConfig", + "Terraform": "header_config", + "Required": false + }, + { + "ROS": "HostConfig", + "Terraform": "host_config", + "Required": false + }, + { + "ROS": "MethodConfig", + "Terraform": "method_config", + "Required": false + }, + { + "ROS": "PathConfig", + "Terraform": "path_config", + "Required": false + }, + { + "ROS": "QueryStringConfig", + "Terraform": "query_string_config", + "Required": false + }, + { + "ROS": "ResponseHeaderConfig", + "Terraform": "response_header_config", + "Required": false + }, + { + "ROS": "ResponseStatusCodeConfig", + "Terraform": "response_status_code_config", + "Required": false + }, + { + "ROS": "SourceIpConfig", + "Terraform": "source_ip_config", + "Required": false + }, + { + "ROS": "Type", + "Terraform": "type", + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "RuleName", + "Terraform": "rule_name", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "RuleId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "ListenerId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ALB::SecurityGroupAttachment", + "Terraform": "alicloud_alb_load_balancer_security_group_attachment" + }, + "ProductCode": "alb", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "LoadBalancerId", + "Terraform": "load_balancer_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ALB::LoadBalancer" + } + ] + }, + { + "ROS": null, + "Terraform": "security_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "SecurityGroupIds", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ], + "Properties": {}, + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ALB::SecurityPolicy", + "Terraform": "alicloud_alb_security_policy" + }, + "ProductCode": "alb", + "Name": { + "zh": "ALB安全策略", + "en": "ALB Security Policy" + }, + "Properties": [ + { + "ROS": "Ciphers", + "Terraform": "ciphers", + "Required": true + }, + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "SecurityPolicyName", + "Terraform": "security_policy_name", + "Required": true + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": "TLSVersions", + "Terraform": "tls_versions", + "Required": false, + "Properties": {}, + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "SecurityPolicyId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ALB::ServerGroup", + "Terraform": "alicloud_alb_server_group" + }, + "ProductCode": "alb", + "Name": { + "zh": "ALB服务器组", + "en": "ALB Server Group" + }, + "Properties": [ + { + "ROS": "ConnectionDrainConfig", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "ConnectionDrainEnabled", + "Terraform": null, + "Required": true + }, + { + "ROS": "ConnectionDrainTimeout", + "Terraform": null, + "Required": true + } + ] + }, + { + "ROS": "CrossZoneEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": "HealthCheckConfig", + "Terraform": "health_check_config", + "Required": true + }, + { + "ROS": "Ipv6Enabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "Protocol", + "Terraform": "protocol", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "Scheduler", + "Terraform": "scheduler", + "Required": false + }, + { + "ROS": "ServerGroupName", + "Terraform": "server_group_name", + "Required": true + }, + { + "ROS": "ServerGroupType", + "Terraform": "server_group_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "servers", + "Required": false + }, + { + "ROS": "ServiceName", + "Terraform": null, + "Required": false + }, + { + "ROS": "SlowStartConfig", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "SlowStartDuration", + "Terraform": null, + "Required": true + }, + { + "ROS": "SlowStartEnabled", + "Terraform": null, + "Required": true + } + ] + }, + { + "ROS": "StickySessionConfig", + "Terraform": "sticky_session_config", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "UchConfig", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Type", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": true + } + ] + }, + { + "ROS": "UpstreamKeepaliveEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": "ServerGroupId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "servers" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::AMQP::Binding", + "Terraform": "alicloud_amqp_binding" + }, + "ProductCode": "ons", + "Name": { + "zh": "AMQP Binding", + "en": "ApsaraMQ for RabbitMQ Binding" + }, + "Properties": [ + { + "ROS": "Argument", + "Terraform": "argument", + "Required": true + }, + { + "ROS": "BindingKey", + "Terraform": "binding_key", + "Required": true + }, + { + "ROS": "BindingType", + "Terraform": "binding_type", + "Required": true + }, + { + "ROS": "DestinationName", + "Terraform": "destination_name", + "Required": true + }, + { + "ROS": "InstanceId", + "Terraform": "instance_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::AMQP::Instance" + } + ] + }, + { + "ROS": "SourceExchange", + "Terraform": "source_exchange", + "Required": true + }, + { + "ROS": "VirtualHost", + "Terraform": null, + "Required": true + }, + { + "ROS": null, + "Terraform": "virtual_host_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::AMQP::Exchange", + "Terraform": "alicloud_amqp_exchange" + }, + "ProductCode": "ons", + "Name": { + "zh": "AMQP Exchange", + "en": "ApsaraMQ for RabbitMQ Exchange" + }, + "Properties": [ + { + "ROS": "AlternateExchange", + "Terraform": "alternate_exchange", + "Required": false + }, + { + "ROS": "AutoDeleteState", + "Terraform": "auto_delete_state", + "Required": true + }, + { + "ROS": "ExchangeName", + "Terraform": "exchange_name", + "Required": true + }, + { + "ROS": "ExchangeType", + "Terraform": "exchange_type", + "Required": true + }, + { + "ROS": "InstanceId", + "Terraform": "instance_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::AMQP::Instance" + } + ] + }, + { + "ROS": "Internal", + "Terraform": "internal", + "Required": true + }, + { + "ROS": "VirtualHost", + "Terraform": null, + "Required": true + }, + { + "ROS": null, + "Terraform": "virtual_host_name", + "Required": false + }, + { + "ROS": "XDelayedType", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "ExchangeName", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::AMQP::Instance", + "Terraform": "alicloud_amqp_instance" + }, + "ProductCode": "ons", + "Name": { + "zh": "AMQP实例", + "en": "ApsaraMQ for RabbitMQ Instance" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "auto_renew", + "Required": false + }, + { + "ROS": "InstanceName", + "Terraform": "instance_name", + "Required": false + }, + { + "ROS": "InstanceType", + "Terraform": "instance_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "max_connections", + "Required": false + }, + { + "ROS": "MaxEipTps", + "Terraform": "max_eip_tps", + "Required": false + }, + { + "ROS": "MaxTps", + "Terraform": "max_tps", + "Required": false + }, + { + "ROS": null, + "Terraform": "modify_type", + "Required": false + }, + { + "ROS": "OrderNum", + "Terraform": null, + "Required": false + }, + { + "ROS": "PayType", + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": "Period", + "Terraform": "period", + "Required": false + }, + { + "ROS": null, + "Terraform": "period_cycle", + "Required": false + }, + { + "ROS": "PeriodUnit", + "Terraform": null, + "Required": false + }, + { + "ROS": "QueueCapacity", + "Terraform": "queue_capacity", + "Required": false + }, + { + "ROS": null, + "Terraform": "renewal_duration", + "Required": false + }, + { + "ROS": null, + "Terraform": "renewal_duration_unit", + "Required": false + }, + { + "ROS": null, + "Terraform": "renewal_status", + "Required": false + }, + { + "ROS": null, + "Terraform": "serverless_charge_type", + "Required": false + }, + { + "ROS": "StorageSize", + "Terraform": "storage_size", + "Required": false + }, + { + "ROS": "SupportEip", + "Terraform": "support_eip", + "Required": false + }, + { + "ROS": "SupportTracing", + "Terraform": "support_tracing", + "Required": false + }, + { + "ROS": "TracingStorageTime", + "Terraform": "tracing_storage_time", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "ClassicEndpoint", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "InstanceId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "PrivateEndpoint", + "Terraform": null + }, + { + "ROS": "PublicEndpoint", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::AMQP::Queue", + "Terraform": "alicloud_amqp_queue" + }, + "ProductCode": "ons", + "Name": { + "zh": "AMQP Queue", + "en": "ApsaraMQ for RabbitMQ Queue" + }, + "Properties": [ + { + "ROS": "AutoDeleteState", + "Terraform": "auto_delete_state", + "Required": false + }, + { + "ROS": "AutoExpireState", + "Terraform": "auto_expire_state", + "Required": false + }, + { + "ROS": "DeadLetterExchange", + "Terraform": "dead_letter_exchange", + "Required": false + }, + { + "ROS": "DeadLetterRoutingKey", + "Terraform": "dead_letter_routing_key", + "Required": false + }, + { + "ROS": "ExclusiveState", + "Terraform": "exclusive_state", + "Required": false + }, + { + "ROS": "InstanceId", + "Terraform": "instance_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::AMQP::Instance" + } + ] + }, + { + "ROS": "MaximumPriority", + "Terraform": "maximum_priority", + "Required": false + }, + { + "ROS": "MaxLength", + "Terraform": "max_length", + "Required": false + }, + { + "ROS": "MessageTTL", + "Terraform": "message_ttl", + "Required": false + }, + { + "ROS": "QueueName", + "Terraform": "queue_name", + "Required": true + }, + { + "ROS": "VirtualHost", + "Terraform": null, + "Required": true + }, + { + "ROS": null, + "Terraform": "virtual_host_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "QueueName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::AMQP::VirtualHost", + "Terraform": "alicloud_amqp_virtual_host" + }, + "ProductCode": "ons", + "Name": { + "zh": "AMQP VirtualHost", + "en": "ApsaraMQ for RabbitMQ Vhost" + }, + "Properties": [ + { + "ROS": "InstanceId", + "Terraform": "instance_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::AMQP::Instance" + } + ] + }, + { + "ROS": "VirtualHost", + "Terraform": null, + "Required": true + }, + { + "ROS": null, + "Terraform": "virtual_host_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "VirtualHost", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::APIG::ApiAttachment", + "Terraform": null + }, + "ProductCode": "apig", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "BackendScene", + "Terraform": null, + "Required": true + }, + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "DomainIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::APIG::Domain" + } + ], + "Type": "list" + }, + { + "ROS": "EnvironmentId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::APIG::Environment" + } + ] + }, + { + "ROS": "HttpApiId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::APIG::HttpApi" + } + ] + }, + { + "ROS": "RouteId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::APIG::Route" + } + ] + }, + { + "ROS": "ServiceConfigs", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "Match", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Conditions", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": false + }, + { + "ROS": "Operator", + "Terraform": null, + "Required": false + }, + { + "ROS": "Type", + "Terraform": null, + "Required": false + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "DefaultMatch", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "Port", + "Terraform": null, + "Required": false + }, + { + "ROS": "Protocol", + "Terraform": null, + "Required": false + }, + { + "ROS": "ServiceId", + "Terraform": null, + "Required": true + }, + { + "ROS": "Version", + "Terraform": null, + "Required": false + }, + { + "ROS": "Weight", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "EnvironmentId", + "Terraform": null + }, + { + "ROS": "HttpApiId", + "Terraform": null + }, + { + "ROS": "RouteId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::APIG::Domain", + "Terraform": null + }, + "ProductCode": "apig", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "CertIdentifier", + "Terraform": null, + "Required": false + }, + { + "ROS": "DomainName", + "Terraform": null, + "Required": true + }, + { + "ROS": "ForceHttps", + "Terraform": null, + "Required": false + }, + { + "ROS": "Http2Option", + "Terraform": null, + "Required": false + }, + { + "ROS": "Protocol", + "Terraform": null, + "Required": true + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false + }, + { + "ROS": "TlsCipherSuitesConfig", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "ConfigType", + "Terraform": null, + "Required": false + }, + { + "ROS": "TlsCipherSuite", + "Terraform": null, + "Required": false, + "Type": "list", + "Properties": [ + { + "ROS": "Name", + "Terraform": null, + "Required": false + } + ] + } + ] + }, + { + "ROS": "TlsMax", + "Terraform": null, + "Required": false + }, + { + "ROS": "TlsMin", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "CertIdentifier", + "Terraform": null + }, + { + "ROS": "DomainId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "DomainName", + "Terraform": null + }, + { + "ROS": "ForceHttps", + "Terraform": null + }, + { + "ROS": "Http2Option", + "Terraform": null + }, + { + "ROS": "Protocol", + "Terraform": null + }, + { + "ROS": "ResourceGroupId", + "Terraform": null + }, + { + "ROS": "TlsCipherSuitesConfig", + "Terraform": null + }, + { + "ROS": "TlsMax", + "Terraform": null + }, + { + "ROS": "TlsMin", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::APIG::Environment", + "Terraform": null + }, + "ProductCode": "apig", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "EnvironmentName", + "Terraform": null, + "Required": true + }, + { + "ROS": "GatewayId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::APIG::Gateway" + } + ] + } + ], + "Attributes": [ + { + "ROS": "Description", + "Terraform": null + }, + { + "ROS": "EnvironmentId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "EnvironmentName", + "Terraform": null + }, + { + "ROS": "GatewayId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::APIG::Gateway", + "Terraform": null + }, + "ProductCode": "apig", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "GatewayName", + "Terraform": null, + "Required": false + }, + { + "ROS": "LogConfig", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Sls", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Enable", + "Terraform": null, + "Required": false + } + ] + } + ] + }, + { + "ROS": "NetworkAccessConfig", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Type", + "Terraform": null, + "Required": true + } + ] + }, + { + "ROS": "PaymentType", + "Terraform": null, + "Required": true + }, + { + "ROS": "Spec", + "Terraform": null, + "Required": true + }, + { + "ROS": "Vpc", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Name", + "Terraform": null, + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ] + }, + { + "ROS": "VSwitch", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ], + "Properties": [ + { + "ROS": "Name", + "Terraform": null, + "Required": false + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ] + }, + { + "ROS": "ZoneConfig", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "SelectOption", + "Terraform": null, + "Required": true + } + ] + } + ], + "Attributes": [ + { + "ROS": "CreateTime", + "Terraform": null + }, + { + "ROS": "Environments", + "Terraform": null + }, + { + "ROS": "ExpireTime", + "Terraform": null + }, + { + "ROS": "GatewayId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "GatewayName", + "Terraform": null + }, + { + "ROS": "LoadBalancers", + "Terraform": null + }, + { + "ROS": "PaymentType", + "Terraform": null + }, + { + "ROS": "SecurityGroup", + "Terraform": null + }, + { + "ROS": "Spec", + "Terraform": null + }, + { + "ROS": "UpdateTime", + "Terraform": null + }, + { + "ROS": "Version", + "Terraform": null + }, + { + "ROS": "Vpc", + "Terraform": null + }, + { + "ROS": "VSwitch", + "Terraform": null + }, + { + "ROS": "Zones", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::APIG::HttpApi", + "Terraform": null + }, + "ProductCode": "apig", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "BasePath", + "Terraform": null, + "Required": false + }, + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "HttpApiName", + "Terraform": null, + "Required": true + }, + { + "ROS": "Protocols", + "Terraform": null, + "Required": true, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "Type", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "BasePath", + "Terraform": null + }, + { + "ROS": "Description", + "Terraform": null + }, + { + "ROS": "Environments", + "Terraform": null + }, + { + "ROS": "HttpApiId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "HttpApiName", + "Terraform": null + }, + { + "ROS": "Protocols", + "Terraform": null + }, + { + "ROS": "Type", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::APIG::Operation", + "Terraform": null + }, + "ProductCode": "apig", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "HttpApiId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::APIG::HttpApi" + } + ] + }, + { + "ROS": "Method", + "Terraform": null, + "Required": true + }, + { + "ROS": "Mock", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Enable", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResponseCode", + "Terraform": null, + "Required": true + }, + { + "ROS": "ResponseContent", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "OperationName", + "Terraform": null, + "Required": true + }, + { + "ROS": "Path", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "CreateTime", + "Terraform": null + }, + { + "ROS": "Description", + "Terraform": null + }, + { + "ROS": "Method", + "Terraform": null + }, + { + "ROS": "Mock", + "Terraform": null + }, + { + "ROS": "OperationId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "OperationName", + "Terraform": null + }, + { + "ROS": "Path", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::APIG::Plugin", + "Terraform": null + }, + "ProductCode": "apig", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "GatewayId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::APIG::Gateway" + } + ] + }, + { + "ROS": "PluginClassId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::APIG::PluginClass" + } + ] + } + ], + "Attributes": [ + { + "ROS": "GatewayId", + "Terraform": null + }, + { + "ROS": "GatewayName", + "Terraform": null + }, + { + "ROS": "PluginClassId", + "Terraform": null + }, + { + "ROS": "PluginId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::APIG::PluginAttachment", + "Terraform": null + }, + "MainResourceType": { + "ResourceType": "ROS/ALIYUN::APIG::Plugin", + "RefProperty": "ROS/PluginId" + }, + "ProductCode": "apig", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "AttachResourceId", + "Terraform": null, + "Required": false + }, + { + "ROS": "AttachResourceIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "AttachResourceType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Enable", + "Terraform": null, + "Required": false + }, + { + "ROS": "EnvironmentId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::APIG::Environment" + } + ] + }, + { + "ROS": "PluginInfo", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "GatewayId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::APIG::Gateway" + } + ] + }, + { + "ROS": "PluginConfig", + "Terraform": null, + "Required": false + }, + { + "ROS": "PluginId", + "Terraform": null, + "Required": true + } + ] + } + ], + "Attributes": [ + { + "ROS": "AttachResourceId", + "Terraform": null + }, + { + "ROS": "AttachResourceIds", + "Terraform": null + }, + { + "ROS": "AttachResourceNames", + "Terraform": null + }, + { + "ROS": "AttachResourceParentIds", + "Terraform": null + }, + { + "ROS": "AttachResourceType", + "Terraform": null + }, + { + "ROS": "Enable", + "Terraform": null + }, + { + "ROS": "EnvironmentId", + "Terraform": null + }, + { + "ROS": "PluginAttachmentId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "PluginClassInfo", + "Terraform": null + }, + { + "ROS": "PluginInfo", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::APIG::PluginClass", + "Terraform": null + }, + "ProductCode": "apig", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "Alias", + "Terraform": null, + "Required": false + }, + { + "ROS": "Description", + "Terraform": null, + "Required": true + }, + { + "ROS": "ExecutePriority", + "Terraform": null, + "Required": true + }, + { + "ROS": "ExecuteStage", + "Terraform": null, + "Required": true + }, + { + "ROS": "PluginClassName", + "Terraform": null, + "Required": true + }, + { + "ROS": "SupportedMinGatewayVersion", + "Terraform": null, + "Required": false + }, + { + "ROS": "Version", + "Terraform": null, + "Required": true + }, + { + "ROS": "VersionDescription", + "Terraform": null, + "Required": true + }, + { + "ROS": "WasmLanguage", + "Terraform": null, + "Required": true + }, + { + "ROS": "WasmUrl", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "Alias", + "Terraform": null + }, + { + "ROS": "Description", + "Terraform": null + }, + { + "ROS": "Document", + "Terraform": null + }, + { + "ROS": "PluginClassName", + "Terraform": null + }, + { + "ROS": "Type", + "Terraform": null + }, + { + "ROS": "WasmLanguage", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::APIG::Policy", + "Terraform": null + }, + "ProductCode": "apig", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "AttachResourceIds", + "Terraform": null, + "Required": true, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "AttachResourceType", + "Terraform": null, + "Required": true + }, + { + "ROS": "EnvironmentId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::APIG::Environment" + } + ] + }, + { + "ROS": "GatewayId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::APIG::Gateway" + } + ] + }, + { + "ROS": "PolicyClassName", + "Terraform": null, + "Required": true + }, + { + "ROS": "PolicyConfig", + "Terraform": null, + "Required": true + }, + { + "ROS": "PolicyName", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "PolicyClassId", + "Terraform": null + }, + { + "ROS": "PolicyClassName", + "Terraform": null + }, + { + "ROS": "PolicyConfig", + "Terraform": null + }, + { + "ROS": "PolicyId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "PolicyName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::APIG::Route", + "Terraform": null + }, + "ProductCode": "apig", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "Backend", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "Scene", + "Terraform": null, + "Required": true + }, + { + "ROS": "Services", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "Name", + "Terraform": null, + "Required": false + }, + { + "ROS": "Port", + "Terraform": null, + "Required": false + }, + { + "ROS": "Protocol", + "Terraform": null, + "Required": false + }, + { + "ROS": "ServiceId", + "Terraform": null, + "Required": false + }, + { + "ROS": "Version", + "Terraform": null, + "Required": false + }, + { + "ROS": "Weight", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + } + ] + }, + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "DomainIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::APIG::Domain" + } + ], + "Type": "list" + }, + { + "ROS": "DomainInfos", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "DomainId", + "Terraform": null, + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": false + }, + { + "ROS": "Protocol", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "EnvironmentInfo", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "Alias", + "Terraform": null, + "Required": false + }, + { + "ROS": "EnvironmentId", + "Terraform": null, + "Required": true + }, + { + "ROS": "GatewayInfo", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "GatewayId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::APIG::Gateway" + } + ] + }, + { + "ROS": "Name", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "Name", + "Terraform": null, + "Required": false + }, + { + "ROS": "SubDomains", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "DomainId", + "Terraform": null, + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": false + }, + { + "ROS": "NetworkType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Protocol", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + } + ] + }, + { + "ROS": "HttpApiId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::APIG::HttpApi" + } + ] + }, + { + "ROS": "Match", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "Headers", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Name", + "Terraform": null, + "Required": false + }, + { + "ROS": "Type", + "Terraform": null, + "Required": false + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "IgnoreUriCase", + "Terraform": null, + "Required": false + }, + { + "ROS": "Methods", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "Path", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "Type", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": true + } + ] + }, + { + "ROS": "QueryParams", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Name", + "Terraform": null, + "Required": false + }, + { + "ROS": "Type", + "Terraform": null, + "Required": false + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + } + ] + }, + { + "ROS": "RouteName", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "Backend", + "Terraform": null + }, + { + "ROS": "Description", + "Terraform": null + }, + { + "ROS": "DomainInfos", + "Terraform": null + }, + { + "ROS": "EnvironmentInfo", + "Terraform": null + }, + { + "ROS": "Match", + "Terraform": null + }, + { + "ROS": "RouteId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "RouteName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::APIG::Service", + "Terraform": null + }, + "ProductCode": "apig", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "Addresses", + "Terraform": null, + "Required": true, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "GatewayId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::APIG::Gateway" + } + ] + }, + { + "ROS": "ServiceName", + "Terraform": null, + "Required": true + }, + { + "ROS": "SourceType", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "Addresses", + "Terraform": null + }, + { + "ROS": "GatewayId", + "Terraform": null + }, + { + "ROS": "ServiceId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "ServiceName", + "Terraform": null + }, + { + "ROS": "SourceType", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ARMS::AddonRelease", + "Terraform": "alicloud_arms_addon_release" + }, + "ProductCode": "arms", + "Name": { + "zh": "ARMS AddonRelease", + "en": "ARMS Addon Release" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "addon_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "addon_release_name", + "Required": false + }, + { + "ROS": "AddonVersion", + "Terraform": "addon_version", + "Required": true + }, + { + "ROS": null, + "Terraform": "aliyun_lang", + "Required": false + }, + { + "ROS": "EnvironmentId", + "Terraform": "environment_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ARMS::Environment" + } + ] + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "ReleaseName", + "Terraform": null, + "Required": false + }, + { + "ROS": "Values", + "Terraform": "values", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Config", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "EnvironmentId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "Release", + "Terraform": null + }, + { + "ROS": "ReleaseName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ARMS::AlertContact", + "Terraform": "alicloud_arms_alert_contact" + }, + "ProductCode": "arms", + "Name": { + "zh": "ARMS报警联系人", + "en": "ARMS Alert Contact" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "alert_contact_name", + "Required": false + }, + { + "ROS": "ContactName", + "Terraform": null, + "Required": true + }, + { + "ROS": "DingRobotWebhookUrl", + "Terraform": "ding_robot_webhook_url", + "Required": false + }, + { + "ROS": "Email", + "Terraform": "email", + "Required": false + }, + { + "ROS": "PhoneNum", + "Terraform": "phone_num", + "Required": false + }, + { + "ROS": "ProxyUserId", + "Terraform": null, + "Required": false + }, + { + "ROS": "RegionId", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemNoc", + "Terraform": "system_noc", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "ContactId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ARMS::AlertContactGroup", + "Terraform": "alicloud_arms_alert_contact_group" + }, + "ProductCode": "arms", + "Name": { + "zh": "ARMS报警联系人组", + "en": "ARMS Alert Contact Group" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "alert_contact_group_name", + "Required": false + }, + { + "ROS": "ContactGroupName", + "Terraform": null, + "Required": true + }, + { + "ROS": "ContactIds", + "Terraform": "contact_ids", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ARMS::AlertContact" + } + ] + }, + { + "ROS": "ProxyUserId", + "Terraform": null, + "Required": false + }, + { + "ROS": "RegionId", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "ContactGroupId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ARMS::ApplyAlertRuleTemplate", + "Terraform": null + }, + "ProductCode": "arms", + "Name": { + "zh": "ARMS Prometheus告警规则", + "en": "ARMS Prometheus Alert Rule Template" + }, + "Properties": [ + { + "ROS": "ClusterIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "TemplateIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "Update", + "Terraform": null, + "Required": false + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ARMS::DeliverTask", + "Terraform": null + }, + "ProductCode": "arms", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "DataSourceId", + "Terraform": null, + "Required": false + }, + { + "ROS": "DataSourceName", + "Terraform": null, + "Required": false + }, + { + "ROS": "ExternalLabel", + "Terraform": null, + "Required": false + }, + { + "ROS": "FilterList", + "Terraform": null, + "Required": false + }, + { + "ROS": "FilterType", + "Terraform": null, + "Required": false + }, + { + "ROS": "TargetList", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "FaultTolerantPolicy", + "Terraform": null, + "Required": false + }, + { + "ROS": "RetryPolicy", + "Terraform": null, + "Required": false + }, + { + "ROS": "TargetName", + "Terraform": null, + "Required": false + }, + { + "ROS": "TargetParam", + "Terraform": null, + "Required": false + }, + { + "ROS": "TargetType", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "TaskDescription", + "Terraform": null, + "Required": false + }, + { + "ROS": "TaskName", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "TaskId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ARMS::Environment", + "Terraform": "alicloud_arms_environment" + }, + "ProductCode": "arms", + "Name": { + "zh": "ARMS Environment", + "en": "ARMS Environment" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "aliyun_lang", + "Required": false + }, + { + "ROS": "BindResourceId", + "Terraform": "bind_resource_id", + "Required": true + }, + { + "ROS": "DeletePromInstance", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "drop_metrics", + "Required": false + }, + { + "ROS": "EnvironmentName", + "Terraform": "environment_name", + "Required": true + }, + { + "ROS": "EnvironmentSubType", + "Terraform": "environment_sub_type", + "Required": true + }, + { + "ROS": "EnvironmentType", + "Terraform": "environment_type", + "Required": true + }, + { + "ROS": "FeePackage", + "Terraform": null, + "Required": false + }, + { + "ROS": "GrafanaWorkspaceId", + "Terraform": null, + "Required": false + }, + { + "ROS": "ManagedType", + "Terraform": "managed_type", + "Required": false + }, + { + "ROS": "PrometheusInstanceId", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "EnvironmentId", + "Terraform": "environment_id" + }, + { + "ROS": "EnvironmentName", + "Terraform": null + }, + { + "ROS": "EnvironmentSubType", + "Terraform": null + }, + { + "ROS": "EnvironmentType", + "Terraform": null + }, + { + "ROS": "FeePackage", + "Terraform": null + }, + { + "ROS": "GrafanaWorkspaceId", + "Terraform": null + }, + { + "ROS": "EnvironmentId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "ManagedType", + "Terraform": null + }, + { + "ROS": "PrometheusInstanceId", + "Terraform": null + }, + { + "ROS": "ResourceGroupId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ARMS::EnvironmentFeature", + "Terraform": "alicloud_arms_env_feature" + }, + "ProductCode": "arms", + "Name": { + "zh": "ARMS EnvironmentFeature", + "en": "ARMS Environment Feature" + }, + "Properties": [ + { + "ROS": "Config", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "env_feature_name", + "Required": false + }, + { + "ROS": "EnvironmentId", + "Terraform": "environment_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ARMS::Environment" + } + ] + }, + { + "ROS": "FeatureName", + "Terraform": null, + "Required": true + }, + { + "ROS": "FeatureVersion", + "Terraform": "feature_version", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "EnvironmentId", + "Terraform": null + }, + { + "ROS": "Feature", + "Terraform": null + }, + { + "ROS": "FeatureName", + "Terraform": null + }, + { + "ROS": "FeatureStatus", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "namespace" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ARMS::ManagedPrometheus", + "Terraform": "alicloud_arms_prometheus" + }, + "ProductCode": "arms", + "Name": { + "zh": "ARMS托管Prometheus", + "en": "ARMS Managed Prometheus" + }, + "Properties": [ + { + "ROS": "ClusterId", + "Terraform": "cluster_id", + "Required": false + }, + { + "ROS": "ClusterName", + "Terraform": "cluster_name", + "Required": false + }, + { + "ROS": "ClusterType", + "Terraform": "cluster_type", + "Required": true + }, + { + "ROS": "GrafanaInstanceId", + "Terraform": "grafana_instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "SecurityGroupId", + "Terraform": "security_group_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "sub_clusters_json", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Attributes": [ + { + "ROS": "ClusterType", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "VpcId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ARMS::Prometheus", + "Terraform": null + }, + "ProductCode": "arms", + "Name": { + "zh": "ARMS Prometheus", + "en": "ARMS Prometheus" + }, + "Properties": [ + { + "ROS": "ClusterId", + "Terraform": null, + "Required": false + }, + { + "ROS": "ClusterType", + "Terraform": null, + "Required": true + }, + { + "ROS": "GrafanaInstanceId", + "Terraform": null, + "Required": true + }, + { + "ROS": "PrometheusName", + "Terraform": null, + "Required": true + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "SecurityGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "SubClustersJson", + "Terraform": null, + "Required": false + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "VpcId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Attributes": [ + { + "ROS": "ClusterId", + "Terraform": null + }, + { + "ROS": "ClusterType", + "Terraform": null + }, + { + "ROS": "GrafanaInstanceId", + "Terraform": null + }, + { + "ROS": "PaymentType", + "Terraform": null + }, + { + "ROS": "PrometheusName", + "Terraform": null + }, + { + "ROS": "ResourceGroupId", + "Terraform": null + }, + { + "ROS": "SecurityGroupId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "SubClustersJson", + "Terraform": null + }, + { + "ROS": "Tags", + "Terraform": null + }, + { + "ROS": "UserId", + "Terraform": null + }, + { + "ROS": "VpcId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ARMS::RetcodeApp", + "Terraform": null + }, + "ProductCode": "arms", + "Name": { + "zh": "ARMS前端监控任务", + "en": "ARMS Frontend Monitoring Job" + }, + "Properties": [ + { + "ROS": "RegionId", + "Terraform": null, + "Required": true + }, + { + "ROS": "RetcodeAppName", + "Terraform": null, + "Required": true + }, + { + "ROS": "RetcodeAppType", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "AppId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "Pid", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ARMS::XTraceApp", + "Terraform": null + }, + "ProductCode": "arms", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "XTraceAppName", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "CreateTime", + "Terraform": null + }, + { + "ROS": "Pid", + "Terraform": null + }, + { + "ROS": "ResourceGroupId", + "Terraform": null + }, + { + "ROS": "Tags", + "Terraform": null + }, + { + "ROS": "XTraceAppName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ASM::ServiceMesh", + "Terraform": "alicloud_service_mesh_service_mesh" + }, + "ProductCode": "asm", + "Name": { + "zh": "ASM服务网格实例", + "en": "ASM Instance" + }, + "Properties": [ + { + "ROS": "AccessLogEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "AccessLogFile", + "Terraform": null, + "Required": false + }, + { + "ROS": "AccessLogFormat", + "Terraform": null, + "Required": false + }, + { + "ROS": "AccessLogProject", + "Terraform": null, + "Required": false + }, + { + "ROS": "AccessLogServiceEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "AccessLogServiceHost", + "Terraform": null, + "Required": false + }, + { + "ROS": "AccessLogServicePort", + "Terraform": null, + "Required": false + }, + { + "ROS": "ApiServerLoadBalancerSpec", + "Terraform": null, + "Required": false + }, + { + "ROS": "ApiServerPublicEip", + "Terraform": null, + "Required": false + }, + { + "ROS": "AuditProject", + "Terraform": null, + "Required": false + }, + { + "ROS": "AutoRenew", + "Terraform": null, + "Required": false + }, + { + "ROS": "AutoRenewPeriod", + "Terraform": null, + "Required": false + }, + { + "ROS": "CertChain", + "Terraform": null, + "Required": false + }, + { + "ROS": "ChargeType", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "cluster_ids", + "Required": false + }, + { + "ROS": "ClusterSpec", + "Terraform": "cluster_spec", + "Required": false + }, + { + "ROS": "ConfigSourceEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "ConfigSourceNacosID", + "Terraform": null, + "Required": false + }, + { + "ROS": "ControlPlaneLogEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "ControlPlaneLogProject", + "Terraform": null, + "Required": false + }, + { + "ROS": "CRAggregationEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "CustomizedPrometheus", + "Terraform": "customized_prometheus", + "Required": false + }, + { + "ROS": "CustomizedZipkin", + "Terraform": null, + "Required": false + }, + { + "ROS": "DNSProxyingEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "DubboFilterEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "Edition", + "Terraform": "edition", + "Required": false + }, + { + "ROS": "EnableACMG", + "Terraform": null, + "Required": false + }, + { + "ROS": "EnableAmbient", + "Terraform": null, + "Required": false + }, + { + "ROS": "EnableAudit", + "Terraform": null, + "Required": false + }, + { + "ROS": "EnableCRHistory", + "Terraform": null, + "Required": false + }, + { + "ROS": "EnableSDSServer", + "Terraform": null, + "Required": false + }, + { + "ROS": "ExcludeInboundPorts", + "Terraform": null, + "Required": false + }, + { + "ROS": "ExcludeIPRanges", + "Terraform": null, + "Required": false + }, + { + "ROS": "ExcludeOutboundPorts", + "Terraform": null, + "Required": false + }, + { + "ROS": "ExistingCaCert", + "Terraform": null, + "Required": false + }, + { + "ROS": "ExistingCaKey", + "Terraform": null, + "Required": false + }, + { + "ROS": "ExistingCaType", + "Terraform": null, + "Required": false + }, + { + "ROS": "ExistingRootCaCert", + "Terraform": null, + "Required": false + }, + { + "ROS": "ExistingRootCaKey", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "extra_configuration", + "Required": false + }, + { + "ROS": "FilterGatewayClusterConfig", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "force", + "Required": false + }, + { + "ROS": "GatewayAPIEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "GuestCluster", + "Terraform": null, + "Required": false + }, + { + "ROS": "IncludeIPRanges", + "Terraform": null, + "Required": false + }, + { + "ROS": "IstioVersion", + "Terraform": null, + "Required": false + }, + { + "ROS": "KialiEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "load_balancer", + "Required": false + }, + { + "ROS": "LocalityLBConf", + "Terraform": null, + "Required": false + }, + { + "ROS": "LocalityLoadBalancing", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "mesh_config", + "Required": false + }, + { + "ROS": "MSEEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "MultiBufferEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "MultiBufferPollDelay", + "Terraform": null, + "Required": false + }, + { + "ROS": "MysqlFilterEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "network", + "Required": false + }, + { + "ROS": "OPA", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "OPALimitCPU", + "Terraform": null, + "Required": false + }, + { + "ROS": "OPALimitMemory", + "Terraform": null, + "Required": false + }, + { + "ROS": "OPALogLevel", + "Terraform": null, + "Required": false + }, + { + "ROS": "OPARequestCPU", + "Terraform": null, + "Required": false + }, + { + "ROS": "OPARequestMemory", + "Terraform": null, + "Required": false + }, + { + "ROS": "OpenAgentPolicy", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "OpaEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "OutboundTrafficPolicy", + "Terraform": null, + "Required": false + }, + { + "ROS": "Period", + "Terraform": null, + "Required": false + }, + { + "ROS": "PilotLoadBalancerSpec", + "Terraform": null, + "Required": false + }, + { + "ROS": "PilotPublicEip", + "Terraform": null, + "Required": false + }, + { + "ROS": "PlaygroundScene", + "Terraform": null, + "Required": false + }, + { + "ROS": "PrometheusUrl", + "Terraform": "prometheus_url", + "Required": false + }, + { + "ROS": "Proxy", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "ClusterDomain", + "Terraform": null, + "Required": false + }, + { + "ROS": "ProxyLimitCPU", + "Terraform": null, + "Required": false + }, + { + "ROS": "ProxyLimitMemory", + "Terraform": null, + "Required": false + }, + { + "ROS": "ProxyRequestCPU", + "Terraform": null, + "Required": false + }, + { + "ROS": "ProxyRequestMemory", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": null, + "Terraform": "service_mesh_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": "Telemetry", + "Terraform": null, + "Required": false + }, + { + "ROS": "TraceSampling", + "Terraform": null, + "Required": false + }, + { + "ROS": "Tracing", + "Terraform": null, + "Required": false + }, + { + "ROS": "UseExistingCA", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "version", + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitches", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "WebAssemblyFilterEnabled", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "ServiceMeshId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "kubeconfig" + }, + { + "ROS": null, + "Terraform": "load_balancer" + }, + { + "ROS": null, + "Terraform": "mesh_config" + }, + { + "ROS": null, + "Terraform": "network" + }, + { + "ROS": "ServiceMeshId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::Aligreen::AuditCallback", + "Terraform": "alicloud_aligreen_audit_callback" + }, + "ProductCode": "lvwang", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "AuditCallbackName", + "Terraform": "audit_callback_name", + "Required": true + }, + { + "ROS": "CallbackSuggestions", + "Terraform": "callback_suggestions", + "Required": true + }, + { + "ROS": "CallbackTypes", + "Terraform": "callback_types", + "Required": true + }, + { + "ROS": "CryptType", + "Terraform": "crypt_type", + "Required": true + }, + { + "ROS": "Url", + "Terraform": "url", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "AuditCallbackName", + "Terraform": null + }, + { + "ROS": "CallbackSuggestions", + "Terraform": null + }, + { + "ROS": "CallbackTypes", + "Terraform": null + }, + { + "ROS": "CryptType", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "Url", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::Aligreen::BizType", + "Terraform": "alicloud_aligreen_biz_type" + }, + "ProductCode": "lvwang", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "BizTypeImport", + "Terraform": "biz_type_import", + "Required": false + }, + { + "ROS": "BizTypeName", + "Terraform": "biz_type_name", + "Required": true + }, + { + "ROS": "CiteTemplate", + "Terraform": "cite_template", + "Required": true + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "IndustryInfo", + "Terraform": "industry_info", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "BizTypeName", + "Terraform": null + }, + { + "ROS": "CiteTemplate", + "Terraform": null + }, + { + "ROS": "Description", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "IndustryInfo", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::Aligreen::Callback", + "Terraform": "alicloud_aligreen_callback" + }, + "ProductCode": "lvwang", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "CallbackName", + "Terraform": "callback_name", + "Required": true + }, + { + "ROS": "CallbackSuggestions", + "Terraform": "callback_suggestions", + "Required": true + }, + { + "ROS": "CallbackTypes", + "Terraform": "callback_types", + "Required": true + }, + { + "ROS": "CallbackUrl", + "Terraform": "callback_url", + "Required": true + }, + { + "ROS": "CryptType", + "Terraform": "crypt_type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "CallbackId", + "Terraform": null + }, + { + "ROS": "CallbackName", + "Terraform": null + }, + { + "ROS": "CallbackSuggestions", + "Terraform": null + }, + { + "ROS": "CallbackTypes", + "Terraform": null + }, + { + "ROS": "CallbackUrl", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "CryptType", + "Terraform": null + }, + { + "ROS": "CallbackId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::Aligreen::ImageLib", + "Terraform": "alicloud_aligreen_image_lib" + }, + "ProductCode": "lvwang", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "BizTypes", + "Terraform": "biz_types", + "Required": false + }, + { + "ROS": "Category", + "Terraform": "category", + "Required": true + }, + { + "ROS": "Enable", + "Terraform": "enable", + "Required": false + }, + { + "ROS": "ImageLibName", + "Terraform": "image_lib_name", + "Required": true + }, + { + "ROS": "Scene", + "Terraform": "scene", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "BizTypes", + "Terraform": null + }, + { + "ROS": "Category", + "Terraform": null + }, + { + "ROS": "Enable", + "Terraform": null + }, + { + "ROS": "ImageLibId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "ImageLibId", + "Terraform": null + }, + { + "ROS": "ImageLibName", + "Terraform": null + }, + { + "ROS": "Scene", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::Aligreen::KeywordLib", + "Terraform": "alicloud_aligreen_keyword_lib" + }, + "ProductCode": "lvwang", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "BizTypes", + "Terraform": "biz_types", + "Required": false + }, + { + "ROS": "Category", + "Terraform": "category", + "Required": false + }, + { + "ROS": "Enable", + "Terraform": "enable", + "Required": false + }, + { + "ROS": "KeywordLibName", + "Terraform": "keyword_lib_name", + "Required": true + }, + { + "ROS": null, + "Terraform": "lang", + "Required": false + }, + { + "ROS": "Language", + "Terraform": "language", + "Required": false + }, + { + "ROS": "LibType", + "Terraform": "lib_type", + "Required": false + }, + { + "ROS": "MatchMode", + "Terraform": "match_mode", + "Required": false + }, + { + "ROS": "ResourceType", + "Terraform": "resource_type", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "BizTypes", + "Terraform": null + }, + { + "ROS": "Category", + "Terraform": null + }, + { + "ROS": "Enable", + "Terraform": null + }, + { + "ROS": "KeywordLibId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "KeywordLibId", + "Terraform": null + }, + { + "ROS": "KeywordLibName", + "Terraform": null + }, + { + "ROS": "Language", + "Terraform": null + }, + { + "ROS": "LibType", + "Terraform": null + }, + { + "ROS": "MatchMode", + "Terraform": null + }, + { + "ROS": "ResourceType", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::Aligreen::OssStockTask", + "Terraform": "alicloud_aligreen_oss_stock_task" + }, + "ProductCode": "lvwang", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "AudioAntispamFreezeConfig", + "Terraform": "audio_antispam_freeze_config", + "Required": false + }, + { + "ROS": "AudioAutoFreezeOpened", + "Terraform": "audio_auto_freeze_opened", + "Required": false + }, + { + "ROS": "AudioMaxSize", + "Terraform": "audio_max_size", + "Required": false + }, + { + "ROS": "AudioOpened", + "Terraform": "audio_opened", + "Required": false + }, + { + "ROS": "AudioScanLimit", + "Terraform": "audio_scan_limit", + "Required": false + }, + { + "ROS": "AudioScenes", + "Terraform": "audio_scenes", + "Required": false + }, + { + "ROS": "AutoFreezeType", + "Terraform": "auto_freeze_type", + "Required": false + }, + { + "ROS": "BizType", + "Terraform": "biz_type", + "Required": false + }, + { + "ROS": "Buckets", + "Terraform": "buckets", + "Required": true + }, + { + "ROS": "CallbackId", + "Terraform": "callback_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::Aligreen::Callback", + "SyncWith": "ROS/CallbackId" + } + ] + }, + { + "ROS": "EndDate", + "Terraform": "end_date", + "Required": false + }, + { + "ROS": "ImageAdFreezeConfig", + "Terraform": "image_ad_freeze_config", + "Required": false + }, + { + "ROS": "ImageAutoFreezeOpened", + "Terraform": "image_auto_freeze_opened", + "Required": false + }, + { + "ROS": "ImageLiveFreezeConfig", + "Terraform": "image_live_freeze_config", + "Required": false + }, + { + "ROS": "ImageOpened", + "Terraform": "image_opened", + "Required": false + }, + { + "ROS": "ImagePornFreezeConfig", + "Terraform": "image_porn_freeze_config", + "Required": false + }, + { + "ROS": "ImageScanLimit", + "Terraform": "image_scan_limit", + "Required": false + }, + { + "ROS": "ImageScenes", + "Terraform": "image_scenes", + "Required": false + }, + { + "ROS": "ImageTerrorismFreezeConfig", + "Terraform": "image_terrorism_freeze_config", + "Required": false + }, + { + "ROS": "OssStockTaskName", + "Terraform": null, + "Required": false + }, + { + "ROS": "ScanImageNoFileType", + "Terraform": "scan_image_no_file_type", + "Required": false + }, + { + "ROS": "StartDate", + "Terraform": "start_date", + "Required": true + }, + { + "ROS": "VideoAdFreezeConfig", + "Terraform": "video_ad_freeze_config", + "Required": false + }, + { + "ROS": "VideoAutoFreezeOpened", + "Terraform": "video_auto_freeze_opened", + "Required": false + }, + { + "ROS": "VideoFrameInterval", + "Terraform": "video_frame_interval", + "Required": false + }, + { + "ROS": "VideoLiveFreezeConfig", + "Terraform": "video_live_freeze_config", + "Required": false + }, + { + "ROS": "VideoMaxFrames", + "Terraform": "video_max_frames", + "Required": false + }, + { + "ROS": "VideoMaxSize", + "Terraform": "video_max_size", + "Required": false + }, + { + "ROS": "VideoOpened", + "Terraform": "video_opened", + "Required": false + }, + { + "ROS": "VideoPornFreezeConfig", + "Terraform": "video_porn_freeze_config", + "Required": false + }, + { + "ROS": "VideoScanLimit", + "Terraform": "video_scan_limit", + "Required": false + }, + { + "ROS": "VideoScenes", + "Terraform": "video_scenes", + "Required": false + }, + { + "ROS": "VideoTerrorismFreezeConfig", + "Terraform": "video_terrorism_freeze_config", + "Required": false + }, + { + "ROS": "VideoVoiceAntispamFreezeConfig", + "Terraform": "video_voice_antispam_freeze_config", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "AudioAntispamFreezeConfig", + "Terraform": null + }, + { + "ROS": "AudioAutoFreezeOpened", + "Terraform": null + }, + { + "ROS": "AudioMaxSize", + "Terraform": null + }, + { + "ROS": "AudioOpened", + "Terraform": null + }, + { + "ROS": "AudioScanLimit", + "Terraform": null + }, + { + "ROS": "AudioScenes", + "Terraform": null + }, + { + "ROS": "AutoFreezeType", + "Terraform": null + }, + { + "ROS": "BizType", + "Terraform": null + }, + { + "ROS": "Buckets", + "Terraform": null + }, + { + "ROS": "CallbackId", + "Terraform": null + }, + { + "ROS": "EndDate", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "ImageAdFreezeConfig", + "Terraform": null + }, + { + "ROS": "ImageAutoFreezeOpened", + "Terraform": null + }, + { + "ROS": "ImageLiveFreezeConfig", + "Terraform": null + }, + { + "ROS": "ImageOpened", + "Terraform": null + }, + { + "ROS": "ImagePornFreezeConfig", + "Terraform": null + }, + { + "ROS": "ImageScanLimit", + "Terraform": null + }, + { + "ROS": "ImageScenes", + "Terraform": null + }, + { + "ROS": "ImageTerrorismFreezeConfig", + "Terraform": null + }, + { + "ROS": "ScanImageNoFileType", + "Terraform": null + }, + { + "ROS": "StartDate", + "Terraform": null + }, + { + "ROS": "VideoAdFreezeConfig", + "Terraform": null + }, + { + "ROS": "VideoAutoFreezeOpened", + "Terraform": null + }, + { + "ROS": "VideoFrameInterval", + "Terraform": null + }, + { + "ROS": "VideoLiveFreezeConfig", + "Terraform": null + }, + { + "ROS": "VideoMaxFrames", + "Terraform": null + }, + { + "ROS": "VideoMaxSize", + "Terraform": null + }, + { + "ROS": "VideoOpened", + "Terraform": null + }, + { + "ROS": "VideoPornFreezeConfig", + "Terraform": null + }, + { + "ROS": "VideoScanLimit", + "Terraform": null + }, + { + "ROS": "VideoScenes", + "Terraform": null + }, + { + "ROS": "VideoTerrorismFreezeConfig", + "Terraform": null + }, + { + "ROS": "VideoVoiceAntispamFreezeConfig", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ApiGateway::Api", + "Terraform": "alicloud_api_gateway_api" + }, + "ProductCode": "apigateway", + "Name": { + "zh": "ApiGateway API", + "en": "API of API Gateway" + }, + "Properties": [ + { + "ROS": "AllowSignatureMethod", + "Terraform": null, + "Required": false + }, + { + "ROS": "AppCodeAuthType", + "Terraform": null, + "Required": false + }, + { + "ROS": "AuthType", + "Terraform": "auth_type", + "Required": false + }, + { + "ROS": "ConstParameters", + "Terraform": "constant_parameters", + "Required": false, + "Properties": [ + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "in", + "Required": false + }, + { + "ROS": null, + "Terraform": "name", + "Required": false + }, + { + "ROS": null, + "Terraform": "value", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "DisableInternet", + "Terraform": null, + "Required": false + }, + { + "ROS": "ErrorCodeSamples", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Code", + "Terraform": null, + "Required": true + }, + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "Message", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "FailResultSample", + "Terraform": null, + "Required": false + }, + { + "ROS": "ServiceConfig.FunctionComputeConfig", + "Terraform": "fc_service_config", + "Required": false, + "Properties": [ + { + "ROS": null, + "Terraform": "*", + "Required": false + } + ] + }, + { + "ROS": "ForceNonceCheck", + "Terraform": "force_nonce_check", + "Required": false + }, + { + "ROS": "GroupId", + "Terraform": "group_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ApiGateway::Group" + } + ] + }, + { + "ROS": null, + "Terraform": "http_service_config", + "Required": false + }, + { + "ROS": null, + "Terraform": "http_vpc_service_config", + "Required": false + }, + { + "ROS": null, + "Terraform": "mock_service_config", + "Required": false + }, + { + "ROS": "ApiName", + "Terraform": "name", + "Required": true + }, + { + "ROS": "OpenIdConnectConfig", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "IdTokenParamName", + "Terraform": null, + "Required": false + }, + { + "ROS": "OpenIdApiType", + "Terraform": null, + "Required": true + }, + { + "ROS": "PublicKey", + "Terraform": null, + "Required": false + }, + { + "ROS": "PublicKeyId", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "RequestConfig", + "Terraform": "request_config", + "Required": true, + "Properties": [ + { + "ROS": null, + "Terraform": "*", + "Required": false + } + ] + }, + { + "ROS": "RequestParameters", + "Terraform": "request_parameters", + "Required": false, + "Properties": [ + { + "ROS": "DefaultValue", + "Terraform": "default_value", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "Location", + "Terraform": "in", + "Required": true + }, + { + "ROS": null, + "Terraform": "in_service", + "Required": false + }, + { + "ROS": "ApiParameterName", + "Terraform": "name", + "Required": true + }, + { + "ROS": null, + "Terraform": "name_service", + "Required": false + }, + { + "ROS": "Required", + "Terraform": "required", + "Required": true + }, + { + "ROS": "ParameterType", + "Terraform": "type", + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "ResultBodyModel", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResultDescriptions", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResultSample", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResultType", + "Terraform": null, + "Required": false + }, + { + "ROS": "ServiceParameters", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Location", + "Terraform": null, + "Required": true + }, + { + "ROS": "ParameterType", + "Terraform": null, + "Required": true + }, + { + "ROS": "ServiceParameterName", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "ServiceParametersMap", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "RequestParameterName", + "Terraform": null, + "Required": true + }, + { + "ROS": "ServiceParameterName", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": null, + "Terraform": "service_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "stage_names", + "Required": false + }, + { + "ROS": "SystemParameters", + "Terraform": "system_parameters", + "Required": false, + "Properties": [ + { + "ROS": "Location", + "Terraform": "in", + "Required": true + }, + { + "ROS": "ParameterName", + "Terraform": "name", + "Required": true + }, + { + "ROS": "ServiceParameterName", + "Terraform": "name_service", + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "Visibility", + "Terraform": null, + "Required": true + }, + { + "ROS": "WebSocketApiType", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "ApiId", + "Terraform": "api_id" + }, + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": "ApiId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ApiGateway::App", + "Terraform": "alicloud_api_gateway_app" + }, + "ProductCode": "apigateway", + "Name": { + "zh": "APP", + "en": "Application" + }, + "Properties": [ + { + "ROS": "AppCode", + "Terraform": null, + "Required": false + }, + { + "ROS": "AppKey", + "Terraform": null, + "Required": false + }, + { + "ROS": "AppSecret", + "Terraform": null, + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "AppName", + "Terraform": "name", + "Required": true + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "AppCode", + "Terraform": null + }, + { + "ROS": "AppKey", + "Terraform": null + }, + { + "ROS": "AppSecret", + "Terraform": null + }, + { + "ROS": "AppId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "Tags", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ApiGateway::Authorization", + "Terraform": "alicloud_api_gateway_app_attachment" + }, + "MainResourceType": { + "ResourceType": "ROS/ALIYUN::ApiGateway::App", + "RefProperty": "ROS/AppId" + }, + "ProductCode": "apigateway", + "Name": { + "zh": "APP授权", + "en": "Grant Permissions on Application" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "api_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ApiGateway::Api" + } + ] + }, + { + "ROS": "ApiIds", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ApiGateway::Api" + } + ] + }, + { + "ROS": null, + "Terraform": "app_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ApiGateway::Api" + } + ] + }, + { + "ROS": "AppIds", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ApiGateway::Api" + } + ] + }, + { + "ROS": "AuthValidTime", + "Terraform": null, + "Required": false + }, + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "GroupId", + "Terraform": "group_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ApiGateway::Group" + } + ] + }, + { + "ROS": "StageName", + "Terraform": "stage_name", + "Required": true + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ApiGateway::CustomDomain", + "Terraform": null + }, + "ProductCode": "apigateway", + "Name": { + "zh": "ApiGateway自定义域名", + "en": "API Gateway Custom Domain" + }, + "Properties": [ + { + "ROS": "CertificateBody", + "Terraform": null, + "Required": false + }, + { + "ROS": "CertificateName", + "Terraform": null, + "Required": false + }, + { + "ROS": "CertificatePrivateKey", + "Terraform": null, + "Required": false + }, + { + "ROS": "DomainName", + "Terraform": null, + "Required": true + }, + { + "ROS": "GroupId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ApiGateway::Group" + } + ] + } + ], + "Attributes": [ + { + "ROS": "CertificateId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ApiGateway::Deployment", + "Terraform": null + }, + "ProductCode": "apigateway", + "Name": { + "zh": "ApiGateway部署", + "en": "API Gateway Deployment" + }, + "Properties": [ + { + "ROS": "ApiId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ApiGateway::Api" + } + ] + }, + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "GroupId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ApiGateway::Group" + } + ] + }, + { + "ROS": "HistoryVersion", + "Terraform": null, + "Required": false + }, + { + "ROS": "StageName", + "Terraform": null, + "Required": true + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ApiGateway::Group", + "Terraform": "alicloud_api_gateway_group" + }, + "ProductCode": "apigateway", + "Name": { + "zh": "API分组", + "en": "API Group" + }, + "Properties": [ + { + "ROS": "BasePath", + "Terraform": "base_path", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "InstanceId", + "Terraform": "instance_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ApiGateway::Instance" + } + ] + }, + { + "ROS": "InternetEnable", + "Terraform": null, + "Required": false + }, + { + "ROS": "GroupName", + "Terraform": "name", + "Required": true + }, + { + "ROS": "PassthroughHeaders", + "Terraform": null, + "Required": false + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "VpcIntranetEnable", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "GroupId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "SubDomain", + "Terraform": "sub_domain" + }, + { + "ROS": "Tags", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "vpc_domain" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ApiGateway::Instance", + "Terraform": "alicloud_api_gateway_instance" + }, + "ProductCode": "apigateway", + "Name": { + "zh": "API网关实例", + "en": "API Gateway Instance" + }, + "Properties": [ + { + "ROS": "AutoPay", + "Terraform": null, + "Required": false + }, + { + "ROS": "ChargeType", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "delete_vpc_ip_block", + "Required": false + }, + { + "ROS": "DeletionForce", + "Terraform": null, + "Required": false + }, + { + "ROS": "Duration", + "Terraform": "duration", + "Required": false + }, + { + "ROS": null, + "Terraform": "egress_ipv6_enable", + "Required": false + }, + { + "ROS": "HttpsPolicy", + "Terraform": "https_policy", + "Required": true + }, + { + "ROS": null, + "Terraform": "instance_cidr", + "Required": false + }, + { + "ROS": "InstanceName", + "Terraform": "instance_name", + "Required": true + }, + { + "ROS": "InstanceSpec", + "Terraform": "instance_spec", + "Required": true + }, + { + "ROS": null, + "Terraform": "instance_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "ipv6_enabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": "PricingCycle", + "Terraform": "pricing_cycle", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": null, + "Terraform": "to_connect_vpc_ip_block", + "Required": false + }, + { + "ROS": null, + "Terraform": "user_vpc_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "vpc_slb_intranet_enable", + "Required": false + }, + { + "ROS": "ZoneId", + "Terraform": "zone_id", + "Required": true + }, + { + "ROS": null, + "Terraform": "zone_vswitch_security_group", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "connect_cidr_blocks" + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "EgressIpv6Enable", + "Terraform": null + }, + { + "ROS": "InstanceId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "InstanceType", + "Terraform": null + }, + { + "ROS": "InternetEgressAddress", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "SupportIpv6", + "Terraform": "support_ipv6" + }, + { + "ROS": "VpcEgressAddress", + "Terraform": null + }, + { + "ROS": "VpcIntranetEnable", + "Terraform": null + }, + { + "ROS": "VpcSlbIntranetEnable", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ApiGateway::LogConfig", + "Terraform": "alicloud_api_gateway_log_config" + }, + "ProductCode": "apigateway", + "Name": { + "zh": "日志配置", + "en": "Log Configuration" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "log_type", + "Required": false + }, + { + "ROS": "SlsLogStore", + "Terraform": "sls_log_store", + "Required": true + }, + { + "ROS": "SlsProject", + "Terraform": "sls_project", + "Required": true + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "SlsLogStore", + "Terraform": null + }, + { + "ROS": "SlsProject", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ApiGateway::Plugin", + "Terraform": "alicloud_api_gateway_plugin" + }, + "ProductCode": "apigateway", + "Name": { + "zh": "API网关插件", + "en": "API Gateway Plug-in" + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "PluginData", + "Terraform": "plugin_data", + "Required": true + }, + { + "ROS": "PluginName", + "Terraform": "plugin_name", + "Required": true + }, + { + "ROS": "PluginType", + "Terraform": "plugin_type", + "Required": true + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "Description", + "Terraform": null + }, + { + "ROS": "PluginId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "PluginData", + "Terraform": null + }, + { + "ROS": "PluginName", + "Terraform": null + }, + { + "ROS": "PluginType", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ApiGateway::PluginAttachment", + "Terraform": "alicloud_api_gateway_plugin_attachment" + }, + "MainResourceType": { + "ResourceType": "ROS/ALIYUN::ApiGateway::Plugin", + "RefProperty": "ROS/PluginId" + }, + "ProductCode": "apigateway", + "Name": { + "zh": "API网关插件绑定", + "en": "Bind API Gateway Plug-in" + }, + "Properties": [ + { + "ROS": "ApiId", + "Terraform": "api_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ApiGateway::Api" + } + ] + }, + { + "ROS": null, + "Terraform": "group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ApiGateway::Group" + } + ] + }, + { + "ROS": "PluginId", + "Terraform": "plugin_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ApiGateway::Plugin" + } + ] + }, + { + "ROS": "StageName", + "Terraform": "stage_name", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "ApiId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "PluginId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ApiGateway::Signature", + "Terraform": null + }, + "ProductCode": "apigateway", + "Name": { + "zh": "ApiGateway后端签名", + "en": "API Gateway Backend Signature" + }, + "Properties": [ + { + "ROS": "SignatureKey", + "Terraform": null, + "Required": true + }, + { + "ROS": "SignatureName", + "Terraform": null, + "Required": true + }, + { + "ROS": "SignatureSecret", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "SignatureId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ApiGateway::SignatureBinding", + "Terraform": null + }, + "MainResourceType": { + "ResourceType": "ROS/ALIYUN::ApiGateway::Signature", + "RefProperty": "ROS/SignatureId" + }, + "ProductCode": "apigateway", + "Name": { + "zh": "ApiGateway后端签名绑定", + "en": "Bind API Gateway Backend Signature" + }, + "Properties": [ + { + "ROS": "ApiIds", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ApiGateway::Api" + } + ] + }, + { + "ROS": "GroupId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ApiGateway::Group" + } + ] + }, + { + "ROS": "SignatureId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ApiGateway::Signature" + } + ] + }, + { + "ROS": "StageName", + "Terraform": null, + "Required": true + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ApiGateway::StageConfig", + "Terraform": null + }, + "ProductCode": "apigateway", + "Name": { + "zh": "ApiGateway环境变量配置", + "en": "Configure API Gateway Environment Variables" + }, + "Properties": [ + { + "ROS": "GroupId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ApiGateway::Group" + } + ] + }, + { + "ROS": "StageName", + "Terraform": null, + "Required": true + }, + { + "ROS": "Variables", + "Terraform": null, + "Required": true + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ApiGateway::TrafficControl", + "Terraform": null + }, + "ProductCode": "apigateway", + "Name": { + "zh": "ApiGateway流控策略", + "en": "API Gateway Throttling Policy" + }, + "Properties": [ + { + "ROS": "ApiDefault", + "Terraform": null, + "Required": true + }, + { + "ROS": "AppDefault", + "Terraform": null, + "Required": false + }, + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "Special", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "SpecialKey", + "Terraform": null, + "Required": true + }, + { + "ROS": "SpecialType", + "Terraform": null, + "Required": true + }, + { + "ROS": "TrafficValue", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "TrafficControlName", + "Terraform": null, + "Required": true + }, + { + "ROS": "TrafficControlUnit", + "Terraform": null, + "Required": true + }, + { + "ROS": "UserDefault", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "TrafficControlId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ApiGateway::TrafficControlBinding", + "Terraform": null + }, + "MainResourceType": { + "ResourceType": "ROS/ALIYUN::ApiGateway::TrafficControl", + "RefProperty": "ROS/TrafficControlId" + }, + "ProductCode": "apigateway", + "Name": { + "zh": "ApiGateway流控策略绑定", + "en": "Attach API Gateway Throttling Policy" + }, + "Properties": [ + { + "ROS": "ApiIds", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ApiGateway::Api" + } + ] + }, + { + "ROS": "GroupId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ApiGateway::Group" + } + ] + }, + { + "ROS": "StageName", + "Terraform": null, + "Required": true + }, + { + "ROS": "TrafficControlId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ApiGateway::TrafficControl" + } + ] + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ApiGateway::VpcAccessConfig", + "Terraform": "alicloud_api_gateway_vpc_access" + }, + "ProductCode": "apigateway", + "Name": { + "zh": "ApiGateway VPC授权配置", + "en": "Configure VPC Access Authorization in API Gateway" + }, + "Properties": [ + { + "ROS": "InstanceId", + "Terraform": "instance_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ApiGateway::Instance" + } + ] + }, + { + "ROS": "Name", + "Terraform": "name", + "Required": true + }, + { + "ROS": "Port", + "Terraform": "port", + "Required": true + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::AppFlow::Flow", + "Terraform": null + }, + "ProductCode": "computenest", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "FlowDesc", + "Terraform": null, + "Required": false + }, + { + "ROS": "FlowId", + "Terraform": null, + "Required": false + }, + { + "ROS": "FlowName", + "Terraform": null, + "Required": true + }, + { + "ROS": "FlowStatus", + "Terraform": null, + "Required": false + }, + { + "ROS": "LaunchFlow", + "Terraform": null, + "Required": false + }, + { + "ROS": "Parameters", + "Terraform": null, + "Required": false + }, + { + "ROS": "Template", + "Terraform": null, + "Required": false + }, + { + "ROS": "TemplateId", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "FlowId", + "Terraform": null + }, + { + "ROS": "WebhookAddress", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::AppFlow::UserAuthConfig", + "Terraform": null + }, + "ProductCode": "computenest", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "AuthConfig", + "Terraform": null, + "Required": true + }, + { + "ROS": "AuthConfigName", + "Terraform": null, + "Required": true + }, + { + "ROS": "ConnectorId", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "AuthConfig", + "Terraform": null + }, + { + "ROS": "AuthConfigId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::BSS::ResourcePackage", + "Terraform": null + }, + "ProductCode": "bss", + "Name": { + "zh": "BSS资源包", + "en": "BOA Resource Plan" + }, + "Properties": [ + { + "ROS": "AutoRenew", + "Terraform": null, + "Required": false + }, + { + "ROS": "AutoRenewPeriod", + "Terraform": null, + "Required": false + }, + { + "ROS": "AutoRenewPeriodUnit", + "Terraform": null, + "Required": false + }, + { + "ROS": "Duration", + "Terraform": null, + "Required": true + }, + { + "ROS": "EffectiveDate", + "Terraform": null, + "Required": false + }, + { + "ROS": "PackageType", + "Terraform": null, + "Required": true + }, + { + "ROS": "PricingCycle", + "Terraform": null, + "Required": false + }, + { + "ROS": "ProductCode", + "Terraform": null, + "Required": true + }, + { + "ROS": "Specification", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "InstanceId", + "Terraform": null + }, + { + "ROS": "OrderId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::BSS::WaitOrder", + "Terraform": null + }, + "ProductCode": "bss", + "Name": { + "zh": "BSS等待订单结束", + "en": "Wait BOA Order Complete" + }, + "Properties": [ + { + "ROS": "CancelOnDelete", + "Terraform": null, + "Required": false + }, + { + "ROS": "OrderIds", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::BSS::ResourcePackage" + } + ] + }, + { + "ROS": "WaitForOrderProduced", + "Terraform": null, + "Required": false + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::BastionHost::Host", + "Terraform": "alicloud_bastionhost_host" + }, + "ProductCode": "bastionhost", + "Name": { + "zh": "BastionHost 主机", + "en": "BH Host" + }, + "Properties": [ + { + "ROS": "ActiveAddressType", + "Terraform": "active_address_type", + "Required": true + }, + { + "ROS": "Comment", + "Terraform": "comment", + "Required": false + }, + { + "ROS": "HostName", + "Terraform": "host_name", + "Required": true + }, + { + "ROS": "HostPrivateAddress", + "Terraform": "host_private_address", + "Required": false + }, + { + "ROS": "HostPublicAddress", + "Terraform": "host_public_address", + "Required": false + }, + { + "ROS": "InstanceId", + "Terraform": "instance_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::BastionHost::Instance" + } + ] + }, + { + "ROS": "InstanceRegionId", + "Terraform": "instance_region_id", + "Required": false + }, + { + "ROS": "OSType", + "Terraform": "os_type", + "Required": false + }, + { + "ROS": "Source", + "Terraform": "source", + "Required": true + }, + { + "ROS": "SourceInstanceId", + "Terraform": "source_instance_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "HostId", + "Terraform": "host_id" + }, + { + "ROS": "HostId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::BastionHost::Instance", + "Terraform": "alicloud_bastionhost_instance" + }, + "ProductCode": "bastionhost", + "Name": { + "zh": "Bastionhost Instance", + "en": "BH Instance" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "ad_auth_server", + "Required": false + }, + { + "ROS": "AutoPay", + "Terraform": null, + "Required": false + }, + { + "ROS": "AutoRenew", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "bandwidth", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "enable_public_access", + "Required": false + }, + { + "ROS": "ExtendedStoragePlans", + "Terraform": null, + "Required": true + }, + { + "ROS": "ExtraBandwidth", + "Terraform": null, + "Required": true + }, + { + "ROS": null, + "Terraform": "ldap_auth_server", + "Required": false + }, + { + "ROS": null, + "Terraform": "license_code", + "Required": false + }, + { + "ROS": "Period", + "Terraform": "period", + "Required": false + }, + { + "ROS": "PeriodUnit", + "Terraform": null, + "Required": false + }, + { + "ROS": "Plan", + "Terraform": null, + "Required": true + }, + { + "ROS": null, + "Terraform": "plan_code", + "Required": false + }, + { + "ROS": null, + "Terraform": "public_white_list", + "Required": false + }, + { + "ROS": null, + "Terraform": "renewal_period_unit", + "Required": false + }, + { + "ROS": null, + "Terraform": "renewal_status", + "Required": false + }, + { + "ROS": null, + "Terraform": "renew_period", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "security_group_ids", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "StartInstanceParam", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "SecurityGroupIds", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ], + "Properties": {}, + "Type": "list" + }, + { + "ROS": "VswitchId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ] + }, + { + "ROS": null, + "Terraform": "storage", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": "Version", + "Terraform": null, + "Required": true + }, + { + "ROS": null, + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Attributes": [ + { + "ROS": "InstanceId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CAS::Certificate", + "Terraform": "alicloud_cas_certificate" + }, + "ProductCode": "cas", + "Name": { + "zh": "CAS证书", + "en": "Certificate of Certificate Management Service" + }, + "Properties": [ + { + "ROS": "Cert", + "Terraform": "cert", + "Required": true + }, + { + "ROS": "Name", + "Terraform": "certificate_name", + "Required": false + }, + { + "ROS": "Key", + "Terraform": "key", + "Required": true + }, + { + "ROS": "Lang", + "Terraform": "lang", + "Required": false + }, + { + "ROS": "Name", + "Terraform": "name", + "Required": true + }, + { + "ROS": "SourceIp", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "CertId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CAS::Order", + "Terraform": null + }, + "ProductCode": "cas", + "Name": { + "zh": "CAS SSL证书购买", + "en": "Purchase SSL Certificate of Certificate Management Service" + }, + "Properties": [ + { + "ROS": "CertBrand", + "Terraform": null, + "Required": true + }, + { + "ROS": "CertType", + "Terraform": null, + "Required": true + }, + { + "ROS": "DomainCnt", + "Terraform": null, + "Required": false + }, + { + "ROS": "DomainType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Period", + "Terraform": null, + "Required": false + }, + { + "ROS": "Service", + "Terraform": null, + "Required": false + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CAS::SslCertificate", + "Terraform": null + }, + "ProductCode": "cas", + "Name": { + "zh": "CAS SslCertificate", + "en": "Certificate Management Service SSL Certificate" + }, + "Properties": [ + { + "ROS": "CertBrand", + "Terraform": null, + "Required": false + }, + { + "ROS": "CertType", + "Terraform": null, + "Required": false + }, + { + "ROS": "CompanyName", + "Terraform": null, + "Required": false + }, + { + "ROS": "Csr", + "Terraform": null, + "Required": false + }, + { + "ROS": "Domains", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "DomainType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Email", + "Terraform": null, + "Required": false + }, + { + "ROS": "Phone", + "Terraform": null, + "Required": false + }, + { + "ROS": "ProductCode", + "Terraform": null, + "Required": false + }, + { + "ROS": "Username", + "Terraform": null, + "Required": false + }, + { + "ROS": "ValidateType", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "CertificateId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "OrderId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CDDC::DedicatedHost", + "Terraform": "alicloud_cddc_dedicated_host" + }, + "ProductCode": "cddc", + "Name": { + "zh": "CDDC专属集群主机", + "en": "ApsaraDB for MyBase Dedicated Cluster Host" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "allocation_status", + "Required": false + }, + { + "ROS": "AutoRenew", + "Terraform": "auto_renew", + "Required": false + }, + { + "ROS": "DedicatedHostGroupId", + "Terraform": "dedicated_host_group_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CDDC::DedicatedHostGroup" + } + ] + }, + { + "ROS": "HostClass", + "Terraform": "host_class", + "Required": true + }, + { + "ROS": "HostName", + "Terraform": "host_name", + "Required": false + }, + { + "ROS": "ImageCategory", + "Terraform": "image_category", + "Required": false + }, + { + "ROS": "OsPassword", + "Terraform": "os_password", + "Required": false + }, + { + "ROS": "PaymentType", + "Terraform": "payment_type", + "Required": true + }, + { + "ROS": "Period", + "Terraform": "period", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "UsedTime", + "Terraform": "used_time", + "Required": false + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "ZoneId", + "Terraform": "zone_id", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "AutoRenew", + "Terraform": null + }, + { + "ROS": "CpuAllocationRatio", + "Terraform": null + }, + { + "ROS": "CpuUsed", + "Terraform": null + }, + { + "ROS": "DedicatedHostGroupId", + "Terraform": null + }, + { + "ROS": "DedicatedHostId", + "Terraform": "dedicated_host_id", + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::DedicatedHost" + } + ] + }, + { + "ROS": "DiskAllocationRatio", + "Terraform": null + }, + { + "ROS": "EcsClassCode", + "Terraform": null + }, + { + "ROS": "HostClass", + "Terraform": null + }, + { + "ROS": "HostCpu", + "Terraform": null + }, + { + "ROS": "HostMem", + "Terraform": null + }, + { + "ROS": "HostName", + "Terraform": null + }, + { + "ROS": "HostStorage", + "Terraform": null + }, + { + "ROS": "HostType", + "Terraform": null + }, + { + "ROS": "DedicatedHostId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "ImageCategory", + "Terraform": null + }, + { + "ROS": "IpAddress", + "Terraform": null + }, + { + "ROS": "MemAllocationRatio", + "Terraform": null + }, + { + "ROS": "MemoryUsed", + "Terraform": null + }, + { + "ROS": "OpenPermission", + "Terraform": null + }, + { + "ROS": "PaymentType", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "StorageUsed", + "Terraform": null + }, + { + "ROS": "VpcId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "ZoneId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CDDC::DedicatedHostGroup", + "Terraform": "alicloud_cddc_dedicated_host_group" + }, + "ProductCode": "cddc", + "Name": { + "zh": "CDDC专属集群", + "en": "ApsaraDB for MyBase Dedicated Cluster" + }, + "Properties": [ + { + "ROS": "AllocationPolicy", + "Terraform": "allocation_policy", + "Required": false + }, + { + "ROS": "CpuAllocationRatio", + "Terraform": "cpu_allocation_ratio", + "Required": false + }, + { + "ROS": "DedicatedHostGroupDesc", + "Terraform": "dedicated_host_group_desc", + "Required": false + }, + { + "ROS": "DiskAllocationRatio", + "Terraform": "disk_allocation_ratio", + "Required": false + }, + { + "ROS": "Engine", + "Terraform": null, + "Required": true + }, + { + "ROS": "HostReplacePolicy", + "Terraform": "host_replace_policy", + "Required": false + }, + { + "ROS": "MemAllocationRatio", + "Terraform": "mem_allocation_ratio", + "Required": false + }, + { + "ROS": "OpenPermission", + "Terraform": "open_permission", + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ], + "Attributes": [ + { + "ROS": "AllocationPolicy", + "Terraform": null + }, + { + "ROS": "BastionInstanceId", + "Terraform": null + }, + { + "ROS": "CpuAllocatedAmount", + "Terraform": null + }, + { + "ROS": "CpuAllocateRation", + "Terraform": null + }, + { + "ROS": "CpuAllocationRatio", + "Terraform": null + }, + { + "ROS": "DedicatedHostGroupDesc", + "Terraform": null + }, + { + "ROS": "DeployType", + "Terraform": null + }, + { + "ROS": "DiskAllocatedAmount", + "Terraform": null + }, + { + "ROS": "DiskAllocateRation", + "Terraform": null + }, + { + "ROS": "DiskAllocationRatio", + "Terraform": null + }, + { + "ROS": "DiskUsedAmount", + "Terraform": null + }, + { + "ROS": "DiskUtility", + "Terraform": null + }, + { + "ROS": "Engine", + "Terraform": null + }, + { + "ROS": "HostNumber", + "Terraform": null + }, + { + "ROS": "HostReplacePolicy", + "Terraform": null + }, + { + "ROS": "DedicatedHostGroupId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "InstanceNumber", + "Terraform": null + }, + { + "ROS": "MemAllocatedAmount", + "Terraform": null + }, + { + "ROS": "MemAllocateRation", + "Terraform": null + }, + { + "ROS": "MemAllocationRatio", + "Terraform": null + }, + { + "ROS": "MemUsedAmount", + "Terraform": null + }, + { + "ROS": "MemUtility", + "Terraform": null + }, + { + "ROS": "OpenPermission", + "Terraform": null + }, + { + "ROS": "Text", + "Terraform": null + }, + { + "ROS": "VpcId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CDDC::MyBase", + "Terraform": null + }, + "ProductCode": "cddc", + "Name": { + "zh": "CDDC MyBase", + "en": "ApsaraDB for MyBase Dedicated Cluster Host" + }, + "Properties": [ + { + "ROS": "AutoRenew", + "Terraform": null, + "Required": false + }, + { + "ROS": "DedicatedHostGroupDescription", + "Terraform": null, + "Required": false + }, + { + "ROS": "DedicatedHostGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CDDC::DedicatedHostGroup" + } + ] + }, + { + "ROS": "ECSClassList", + "Terraform": null, + "Required": true, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "EcsDeploymentSetId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::DeploymentSet" + } + ] + }, + { + "ROS": "EcsHostName", + "Terraform": null, + "Required": false + }, + { + "ROS": "EcsInstanceName", + "Terraform": null, + "Required": false + }, + { + "ROS": "EcsUniqueSuffix", + "Terraform": null, + "Required": false + }, + { + "ROS": "Engine", + "Terraform": null, + "Required": true + }, + { + "ROS": "ImageId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::CustomImage" + } + ] + }, + { + "ROS": "InternetChargeType", + "Terraform": null, + "Required": false + }, + { + "ROS": "InternetMaxBandwidthOut", + "Terraform": null, + "Required": false + }, + { + "ROS": "KeyPairName", + "Terraform": null, + "Required": false + }, + { + "ROS": "OsPassword", + "Terraform": null, + "Required": false + }, + { + "ROS": "PasswordInherit", + "Terraform": null, + "Required": false + }, + { + "ROS": "PayType", + "Terraform": null, + "Required": true + }, + { + "ROS": "Period", + "Terraform": null, + "Required": true + }, + { + "ROS": "PeriodType", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "SecurityGroupId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "UserData", + "Terraform": null, + "Required": false + }, + { + "ROS": "UserDataInBase64", + "Terraform": null, + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "ZoneId", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "InstanceIds", + "Terraform": null + }, + { + "ROS": "OrderIds", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CEN::CenBandwidthLimit", + "Terraform": "alicloud_cen_bandwidth_limit" + }, + "ProductCode": "cbn", + "Name": { + "zh": "CEN跨地域互连带宽", + "en": "CEN Cross-region Connection Bandwidth Limit" + }, + "Properties": [ + { + "ROS": "BandwidthLimit", + "Terraform": "bandwidth_limit", + "Required": true + }, + { + "ROS": "BandwidthType", + "Terraform": null, + "Required": false + }, + { + "ROS": "CenId", + "Terraform": "instance_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::CenInstance" + } + ] + }, + { + "ROS": "LocalRegionId", + "Terraform": null, + "Required": true + }, + { + "ROS": "OppositeRegionId", + "Terraform": null, + "Required": true + }, + { + "ROS": null, + "Terraform": "region_ids", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CEN::CenBandwidthPackage", + "Terraform": "alicloud_cen_bandwidth_package" + }, + "ProductCode": "cbn", + "Name": { + "zh": "CEN带宽包", + "en": "CEN Bandwidth Plan" + }, + "Properties": [ + { + "ROS": "AutoPay", + "Terraform": null, + "Required": false + }, + { + "ROS": "AutoRenew", + "Terraform": null, + "Required": false + }, + { + "ROS": "AutoRenewDuration", + "Terraform": null, + "Required": false + }, + { + "ROS": "Bandwidth", + "Terraform": "bandwidth", + "Required": true + }, + { + "ROS": null, + "Terraform": "cen_bandwidth_package_name", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "GeographicRegionAId", + "Terraform": "geographic_region_a_id", + "Required": true + }, + { + "ROS": "GeographicRegionBId", + "Terraform": "geographic_region_b_id", + "Required": true + }, + { + "ROS": "Name", + "Terraform": null, + "Required": false + }, + { + "ROS": "BandwidthPackageChargeType", + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": "Period", + "Terraform": "period", + "Required": false + }, + { + "ROS": "PricingCycle", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "expired_time" + }, + { + "ROS": "CenBandwidthPackageId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CEN::CenBandwidthPackageAssociation", + "Terraform": "alicloud_cen_bandwidth_package_attachment" + }, + "MainResourceType": { + "ResourceType": "ROS/ALIYUN::CEN::CenBandwidthPackage", + "RefProperty": "ROS/CenBandwidthPackageId" + }, + "ProductCode": "cbn", + "Name": { + "zh": "绑定CEN带宽包", + "en": "Associate CEN Bandwidth Plan" + }, + "Properties": [ + { + "ROS": "CenBandwidthPackageId", + "Terraform": "bandwidth_package_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::CenBandwidthPackage" + } + ] + }, + { + "ROS": "CenId", + "Terraform": "instance_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::CenInstance" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CEN::CenInstance", + "Terraform": "alicloud_cen_instance" + }, + "ProductCode": "cbn", + "Name": { + "zh": "云企业网实例", + "en": "CEN Instance" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "cen_instance_name", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": false + }, + { + "ROS": "ProtectionLevel", + "Terraform": "protection_level", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": "CenId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CEN::CenInstanceAttachment", + "Terraform": "alicloud_cen_instance_attachment" + }, + "MainResourceType": { + "ResourceType": "ROS/ALIYUN::CEN::CenInstance", + "RefProperty": "ROS/CenId" + }, + "ProductCode": "cbn", + "Name": { + "zh": "云企业网实例加载网络实例", + "en": "Attach Network Instance to CEN Instance" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "cen_owner_id", + "Required": false + }, + { + "ROS": "ChildInstanceId", + "Terraform": "child_instance_id", + "Required": true + }, + { + "ROS": "ChildInstanceOwnerId", + "Terraform": "child_instance_owner_id", + "Required": false + }, + { + "ROS": "ChildInstanceRegionId", + "Terraform": "child_instance_region_id", + "Required": true + }, + { + "ROS": "ChildInstanceType", + "Terraform": "child_instance_type", + "Required": true + }, + { + "ROS": "CenId", + "Terraform": "instance_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::CenInstance" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CEN::CenRouteMap", + "Terraform": "alicloud_cen_route_map" + }, + "ProductCode": "cbn", + "Name": { + "zh": "CEN路由策略", + "en": "CEN Routing Policy" + }, + "Properties": [ + { + "ROS": "AsPathMatchMode", + "Terraform": "as_path_match_mode", + "Required": false + }, + { + "ROS": "CenId", + "Terraform": "cen_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::CenInstance" + } + ] + }, + { + "ROS": "CenRegionId", + "Terraform": "cen_region_id", + "Required": true + }, + { + "ROS": "CidrMatchMode", + "Terraform": "cidr_match_mode", + "Required": false + }, + { + "ROS": "CommunityMatchMode", + "Terraform": "community_match_mode", + "Required": false + }, + { + "ROS": "CommunityOperateMode", + "Terraform": "community_operate_mode", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "DestinationChildInstanceTypes", + "Terraform": "destination_child_instance_types", + "Required": false + }, + { + "ROS": "DestinationCidrBlocks", + "Terraform": "destination_cidr_blocks", + "Required": false + }, + { + "ROS": "DestinationInstanceIds", + "Terraform": "destination_instance_ids", + "Required": false + }, + { + "ROS": "DestinationInstanceIdsReverseMatch", + "Terraform": "destination_instance_ids_reverse_match", + "Required": false + }, + { + "ROS": "DestinationRouteTableIds", + "Terraform": "destination_route_table_ids", + "Required": false + }, + { + "ROS": "MapResult", + "Terraform": "map_result", + "Required": true + }, + { + "ROS": "MatchAsns", + "Terraform": "match_asns", + "Required": false + }, + { + "ROS": "MatchCommunitySet", + "Terraform": "match_community_set", + "Required": false + }, + { + "ROS": "NextPriority", + "Terraform": "next_priority", + "Required": false + }, + { + "ROS": "OperateCommunitySet", + "Terraform": "operate_community_set", + "Required": false + }, + { + "ROS": "Preference", + "Terraform": "preference", + "Required": false + }, + { + "ROS": "PrependAsPath", + "Terraform": "prepend_as_path", + "Required": false + }, + { + "ROS": "Priority", + "Terraform": "priority", + "Required": true + }, + { + "ROS": "RouteTypes", + "Terraform": "route_types", + "Required": false + }, + { + "ROS": "SourceChildInstanceTypes", + "Terraform": "source_child_instance_types", + "Required": false + }, + { + "ROS": "SourceInstanceIds", + "Terraform": "source_instance_ids", + "Required": false + }, + { + "ROS": "SourceInstanceIdsReverseMatch", + "Terraform": "source_instance_ids_reverse_match", + "Required": false + }, + { + "ROS": "SourceRegionIds", + "Terraform": "source_region_ids", + "Required": false + }, + { + "ROS": "SourceRouteTableIds", + "Terraform": "source_route_table_ids", + "Required": false + }, + { + "ROS": null, + "Terraform": "transit_router_route_table_id", + "Required": false + }, + { + "ROS": "TransmitDirection", + "Terraform": "transmit_direction", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "RouteMapId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "RouteMapId", + "Terraform": "route_map_id" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CEN::CenRouteService", + "Terraform": "alicloud_cen_route_service" + }, + "ProductCode": "cbn", + "Name": { + "zh": "CEN访问云服务", + "en": "Access Service from CEN" + }, + "Properties": [ + { + "ROS": "AccessRegionId", + "Terraform": "access_region_id", + "Required": true + }, + { + "ROS": "CenId", + "Terraform": "cen_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::CenInstance" + } + ] + }, + { + "ROS": "ConflictIgnore", + "Terraform": null, + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "Host", + "Terraform": "host", + "Required": true + }, + { + "ROS": "HostRegionId", + "Terraform": "host_region_id", + "Required": true + }, + { + "ROS": "HostVpcId", + "Terraform": "host_vpc_id", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "Id", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CEN::CenVbrHealthCheck", + "Terraform": "alicloud_cen_vbr_health_check" + }, + "ProductCode": "cbn", + "Name": { + "zh": "CEN边界路由器健康检查", + "en": "CEN VBR Health Check" + }, + "Properties": [ + { + "ROS": "CenId", + "Terraform": "cen_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::CenInstance" + } + ] + }, + { + "ROS": "HealthCheckInterval", + "Terraform": "health_check_interval", + "Required": false + }, + { + "ROS": "HealthCheckSourceIp", + "Terraform": "health_check_source_ip", + "Required": false + }, + { + "ROS": "HealthCheckTargetIp", + "Terraform": "health_check_target_ip", + "Required": true + }, + { + "ROS": "HealthyThreshold", + "Terraform": "healthy_threshold", + "Required": false + }, + { + "ROS": "VbrInstanceId", + "Terraform": "vbr_instance_id", + "Required": true + }, + { + "ROS": "VbrInstanceOwnerId", + "Terraform": "vbr_instance_owner_id", + "Required": false + }, + { + "ROS": "VbrInstanceRegionId", + "Terraform": "vbr_instance_region_id", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "CenId", + "Terraform": null + }, + { + "ROS": "HealthCheckInterval", + "Terraform": null + }, + { + "ROS": "HealthCheckSourceIp", + "Terraform": null + }, + { + "ROS": "HealthCheckTargetIp", + "Terraform": null + }, + { + "ROS": "HealthyThreshold", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "VbrInstanceId", + "Terraform": null + }, + { + "ROS": "VbrInstanceOwnerId", + "Terraform": null + }, + { + "ROS": "VbrInstanceRegionId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CEN::ChildInstanceRouteEntryToAttachment", + "Terraform": "alicloud_cen_child_instance_route_entry_to_attachment" + }, + "ProductCode": "cbn", + "Name": { + "zh": "添加CEN路由条目", + "en": "Add CEN Route Entry" + }, + "Properties": [ + { + "ROS": "CenId", + "Terraform": "cen_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::CenInstance" + } + ] + }, + { + "ROS": null, + "Terraform": "child_instance_route_table_id", + "Required": false + }, + { + "ROS": "DestinationCidrBlock", + "Terraform": "destination_cidr_block", + "Required": true + }, + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": "RouteTableId", + "Terraform": null, + "Required": true + }, + { + "ROS": "TransitRouterAttachmentId", + "Terraform": "transit_router_attachment_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::TransitRouterPeerAttachment" + }, + { + "ResourceType": "ROS/ALIYUN::CEN::TransitRouterVbrAttachment" + }, + { + "ResourceType": "ROS/ALIYUN::CEN::TransitRouterVpcAttachment" + }, + { + "ResourceType": "ROS/ALIYUN::CEN::TransitRouterVpnAttachment" + } + ] + } + ], + "Attributes": [ + { + "ROS": "CenId", + "Terraform": null + }, + { + "ROS": "DestinationCidrBlock", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "RouteTableId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "service_type" + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "TransitRouterAttachmentId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CEN::RouteEntry", + "Terraform": "alicloud_cen_route_entry" + }, + "ProductCode": "cbn", + "Name": { + "zh": "CEN路由条目", + "en": "CEN Route Entry" + }, + "Properties": [ + { + "ROS": "CenId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::CenInstance" + } + ] + }, + { + "ROS": "ChildInstanceId", + "Terraform": null, + "Required": true + }, + { + "ROS": "ChildInstanceRegionId", + "Terraform": null, + "Required": true + }, + { + "ROS": "ChildInstanceRouteTableId", + "Terraform": null, + "Required": true + }, + { + "ROS": "ChildInstanceType", + "Terraform": null, + "Required": true + }, + { + "ROS": null, + "Terraform": "cidr_block", + "Required": false + }, + { + "ROS": "DestinationCidrBlock", + "Terraform": null, + "Required": true + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::CenInstance" + } + ] + }, + { + "ROS": null, + "Terraform": "route_table_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CEN::TransitRouter", + "Terraform": "alicloud_cen_transit_router" + }, + "ProductCode": "cbn", + "Name": { + "zh": "CEN转发路由器实例", + "en": "CEN Transit Router" + }, + "Properties": [ + { + "ROS": "CenId", + "Terraform": "cen_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::CenInstance" + } + ] + }, + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": null, + "Terraform": "support_multicast", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": "TransitRouterDescription", + "Terraform": "transit_router_description", + "Required": false + }, + { + "ROS": "TransitRouterName", + "Terraform": "transit_router_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "AliUid", + "Terraform": null + }, + { + "ROS": "CenId", + "Terraform": null + }, + { + "ROS": "TransitRouterId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "SystemTransitRouterRouteTableId", + "Terraform": null + }, + { + "ROS": "TransitRouterDescription", + "Terraform": null + }, + { + "ROS": "TransitRouterId", + "Terraform": "transit_router_id" + }, + { + "ROS": "TransitRouterName", + "Terraform": null + }, + { + "ROS": "Type", + "Terraform": "type" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CEN::TransitRouterPeerAttachment", + "Terraform": "alicloud_cen_transit_router_peer_attachment" + }, + "ProductCode": "cbn", + "Name": { + "zh": "CEN跨地域连接", + "en": "CEN Cross-region Connection" + }, + "Properties": [ + { + "ROS": "AutoPublishRouteEnabled", + "Terraform": "auto_publish_route_enabled", + "Required": false + }, + { + "ROS": "Bandwidth", + "Terraform": "bandwidth", + "Required": false + }, + { + "ROS": null, + "Terraform": "bandwidth_type", + "Required": false + }, + { + "ROS": "CenBandwidthPackageId", + "Terraform": "cen_bandwidth_package_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::CenBandwidthPackage" + } + ] + }, + { + "ROS": "CenId", + "Terraform": "cen_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::CenInstance" + } + ] + }, + { + "ROS": null, + "Terraform": "default_link_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": "PeerTransitRouterId", + "Terraform": "peer_transit_router_id", + "Required": true + }, + { + "ROS": "PeerTransitRouterRegionId", + "Terraform": "peer_transit_router_region_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_type", + "Required": false + }, + { + "ROS": "TransitRouterAttachmentDescription", + "Terraform": "transit_router_attachment_description", + "Required": false + }, + { + "ROS": "TransitRouterAttachmentName", + "Terraform": "transit_router_attachment_name", + "Required": false + }, + { + "ROS": "TransitRouterId", + "Terraform": "transit_router_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::TransitRouter" + } + ] + } + ], + "Attributes": [ + { + "ROS": "AutoPublishRouteEnabled", + "Terraform": null + }, + { + "ROS": "Bandwidth", + "Terraform": null + }, + { + "ROS": "CenBandwidthPackageId", + "Terraform": null + }, + { + "ROS": "CenId", + "Terraform": null + }, + { + "ROS": "ClientToken", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "GeographicSpanId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "PeerTransitRouterId", + "Terraform": null + }, + { + "ROS": "PeerTransitRouterOwnerId", + "Terraform": null + }, + { + "ROS": "PeerTransitRouterRegionId", + "Terraform": null + }, + { + "ROS": "ResourceType", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "TransitRouterAttachmentDescription", + "Terraform": null + }, + { + "ROS": "TransitRouterAttachmentId", + "Terraform": "transit_router_attachment_id" + }, + { + "ROS": "TransitRouterAttachmentName", + "Terraform": null + }, + { + "ROS": "TransitRouterId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CEN::TransitRouterRouteEntry", + "Terraform": "alicloud_cen_transit_router_route_entry" + }, + "ProductCode": "cbn", + "Name": { + "zh": "添加CEN路由条目", + "en": "Add CEN Route Entry" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": "TransitRouterRouteEntryDescription", + "Terraform": "transit_router_route_entry_description", + "Required": false + }, + { + "ROS": "TransitRouterRouteEntryDestinationCidrBlock", + "Terraform": "transit_router_route_entry_destination_cidr_block", + "Required": true + }, + { + "ROS": "TransitRouterRouteEntryName", + "Terraform": "transit_router_route_entry_name", + "Required": false + }, + { + "ROS": "TransitRouterRouteEntryNextHopId", + "Terraform": "transit_router_route_entry_next_hop_id", + "Required": false + }, + { + "ROS": "TransitRouterRouteEntryNextHopType", + "Terraform": "transit_router_route_entry_next_hop_type", + "Required": true + }, + { + "ROS": "TransitRouterRouteTableId", + "Terraform": "transit_router_route_table_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::TransitRouterRouteTable" + } + ] + } + ], + "Attributes": [ + { + "ROS": "TransitRouterRouteEntryId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "TransitRouterRouteEntryDescription", + "Terraform": null + }, + { + "ROS": "TransitRouterRouteEntryDestinationCidrBlock", + "Terraform": null + }, + { + "ROS": "TransitRouterRouteEntryId", + "Terraform": "transit_router_route_entry_id" + }, + { + "ROS": "TransitRouterRouteEntryName", + "Terraform": null + }, + { + "ROS": "TransitRouterRouteEntryNextHopId", + "Terraform": null + }, + { + "ROS": "TransitRouterRouteEntryNextHopType", + "Terraform": null + }, + { + "ROS": "TransitRouterRouteEntryType", + "Terraform": null + }, + { + "ROS": "TransitRouterRouteTableId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CEN::TransitRouterRouteTable", + "Terraform": "alicloud_cen_transit_router_route_table" + }, + "ProductCode": "cbn", + "Name": { + "zh": "CEN路由表", + "en": "CEN Route Table" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": "TransitRouterId", + "Terraform": "transit_router_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::TransitRouter" + } + ] + }, + { + "ROS": "TransitRouterRouteTableDescription", + "Terraform": "transit_router_route_table_description", + "Required": false + }, + { + "ROS": "TransitRouterRouteTableName", + "Terraform": "transit_router_route_table_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "ClientToken", + "Terraform": null + }, + { + "ROS": "TransitRouterRouteTableId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "TransitRouterId", + "Terraform": null + }, + { + "ROS": "TransitRouterRouteTableDescription", + "Terraform": null + }, + { + "ROS": "TransitRouterRouteTableId", + "Terraform": "transit_router_route_table_id" + }, + { + "ROS": "TransitRouterRouteTableName", + "Terraform": null + }, + { + "ROS": "TransitRouterRouteTableType", + "Terraform": "transit_router_route_table_type" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CEN::TransitRouterRouteTableAssociation", + "Terraform": "alicloud_cen_transit_router_route_table_association" + }, + "MainResourceType": { + "ResourceType": "ROS/ALIYUN::CEN::TransitRouterRouteTable", + "RefProperty": "ROS/TransitRouterRouteTableId" + }, + "ProductCode": "cbn", + "Name": { + "zh": "关联CEN转发关系", + "en": "CEN Associated Forwarding Correlation" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": "TransitRouterAttachmentId", + "Terraform": "transit_router_attachment_id", + "Required": true + }, + { + "ROS": "TransitRouterRouteTableId", + "Terraform": "transit_router_route_table_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::TransitRouterRouteTable" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "ResourceId", + "Terraform": null + }, + { + "ROS": "ResourceType", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "TransitRouterAttachmentId", + "Terraform": null + }, + { + "ROS": "TransitRouterRouteTableId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CEN::TransitRouterRouteTablePropagation", + "Terraform": "alicloud_cen_transit_router_route_table_propagation" + }, + "ProductCode": "cbn", + "Name": { + "zh": "CEN路由学习关系", + "en": "CEN Route Learning Correlation" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": "TransitRouterAttachmentId", + "Terraform": "transit_router_attachment_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::TransitRouterPeerAttachment" + }, + { + "ResourceType": "ROS/ALIYUN::CEN::TransitRouterVbrAttachment" + }, + { + "ResourceType": "ROS/ALIYUN::CEN::TransitRouterVpcAttachment" + }, + { + "ResourceType": "ROS/ALIYUN::CEN::TransitRouterVpnAttachment" + } + ] + }, + { + "ROS": "TransitRouterRouteTableId", + "Terraform": "transit_router_route_table_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::TransitRouterRouteTable" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "ResourceId", + "Terraform": null + }, + { + "ROS": "ResourceType", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "TransitRouterAttachmentId", + "Terraform": null + }, + { + "ROS": "TransitRouterRouteTableId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CEN::TransitRouterVbrAttachment", + "Terraform": "alicloud_cen_transit_router_vbr_attachment" + }, + "ProductCode": "cbn", + "Name": { + "zh": "CEN边界路由器VBR连接", + "en": "Connect VBR to Transit Router via CEN" + }, + "Properties": [ + { + "ROS": "AutoPublishRouteEnabled", + "Terraform": "auto_publish_route_enabled", + "Required": false + }, + { + "ROS": "CenId", + "Terraform": "cen_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::CenInstance" + } + ] + }, + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "route_table_association_enabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "route_table_propagation_enabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": "TransitRouterAttachmentDescription", + "Terraform": "transit_router_attachment_description", + "Required": false + }, + { + "ROS": "TransitRouterAttachmentName", + "Terraform": "transit_router_attachment_name", + "Required": false + }, + { + "ROS": "TransitRouterId", + "Terraform": "transit_router_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::TransitRouter" + } + ] + }, + { + "ROS": "VbrId", + "Terraform": "vbr_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::VirtualBorderRouter" + } + ] + }, + { + "ROS": "VbrOwnerId", + "Terraform": "vbr_owner_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "AutoPublishRouteEnabled", + "Terraform": null + }, + { + "ROS": "CenId", + "Terraform": null + }, + { + "ROS": "ClientToken", + "Terraform": null + }, + { + "ROS": "TransitRouterAttachmentId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "ResourceType", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "TransitRouterAttachmentDescription", + "Terraform": null + }, + { + "ROS": "TransitRouterAttachmentId", + "Terraform": "transit_router_attachment_id" + }, + { + "ROS": "TransitRouterAttachmentName", + "Terraform": null + }, + { + "ROS": "TransitRouterId", + "Terraform": null + }, + { + "ROS": "VbrId", + "Terraform": null + }, + { + "ROS": "VbrOwnerId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CEN::TransitRouterVpcAttachment", + "Terraform": "alicloud_cen_transit_router_vpc_attachment" + }, + "ProductCode": "cbn", + "Name": { + "zh": "CEN专有网络VPC连接", + "en": "Connect VPC to Transit Router via CEN" + }, + "Properties": [ + { + "ROS": "AutoCreateVpcRoute", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "auto_publish_route_enabled", + "Required": false + }, + { + "ROS": "CenId", + "Terraform": "cen_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::CenInstance" + } + ] + }, + { + "ROS": "DeletionForce", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": null, + "Terraform": "force_delete", + "Required": false + }, + { + "ROS": "ChargeType", + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_type", + "Required": false + }, + { + "ROS": "RouteTableAssociationEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "RouteTablePropagationEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": "TransitRouterAttachmentDescription", + "Terraform": "transit_router_attachment_description", + "Required": false + }, + { + "ROS": "TransitRouterAttachmentName", + "Terraform": null, + "Required": false + }, + { + "ROS": "TransitRouterId", + "Terraform": "transit_router_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::TransitRouter" + } + ] + }, + { + "ROS": null, + "Terraform": "transit_router_vpc_attachment_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "transit_router_vpc_attachment_options", + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VpcOwnerId", + "Terraform": "vpc_owner_id", + "Required": false + }, + { + "ROS": "ZoneMappings", + "Terraform": "zone_mappings", + "Required": true, + "Properties": [ + { + "ROS": null, + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "ZoneId", + "Terraform": "zone_id", + "Required": true + } + ], + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "CenId", + "Terraform": null + }, + { + "ROS": "ClientToken", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "TransitRouterAttachmentId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "ResourceType", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "TransitRouterAttachmentDescription", + "Terraform": null + }, + { + "ROS": "TransitRouterAttachmentId", + "Terraform": "transit_router_attachment_id" + }, + { + "ROS": "TransitRouterAttachmentName", + "Terraform": null + }, + { + "ROS": "TransitRouterId", + "Terraform": null + }, + { + "ROS": "VpcId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VpcOwnerId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CEN::TransitRouterVpnAttachment", + "Terraform": "alicloud_cen_transit_router_vpn_attachment" + }, + "ProductCode": "cbn", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "AutoPublishRouteEnabled", + "Terraform": "auto_publish_route_enabled", + "Required": false + }, + { + "ROS": "CenId", + "Terraform": "cen_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::CenInstance" + } + ] + }, + { + "ROS": "DeletionForce", + "Terraform": null, + "Required": false + }, + { + "ROS": "RouteTableAssociationEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "RouteTablePropagationEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "TransitRouterAttachmentDescription", + "Terraform": "transit_router_attachment_description", + "Required": false + }, + { + "ROS": "TransitRouterAttachmentName", + "Terraform": "transit_router_attachment_name", + "Required": false + }, + { + "ROS": "TransitRouterId", + "Terraform": "transit_router_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::TransitRouter" + } + ] + }, + { + "ROS": "VpnId", + "Terraform": "vpn_id", + "Required": true + }, + { + "ROS": "VpnOwnerId", + "Terraform": "vpn_owner_id", + "Required": false + }, + { + "ROS": "ZoneId", + "Terraform": "zone", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "TransitRouterAttachmentId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CLOUDFW::AddressBook", + "Terraform": "alicloud_cloud_firewall_address_book" + }, + "ProductCode": "cfw", + "Name": { + "zh": "安全访问控制地址簿", + "en": "Access Control Address Book" + }, + "Properties": [ + { + "ROS": "AddressList", + "Terraform": "address_list", + "Required": false + }, + { + "ROS": "AutoAddTagEcs", + "Terraform": "auto_add_tag_ecs", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": true + }, + { + "ROS": "TagList", + "Terraform": "ecs_tags", + "Required": false, + "Properties": [ + { + "ROS": "TagKey", + "Terraform": "tag_key", + "Required": false + }, + { + "ROS": "TagValue", + "Terraform": "tag_value", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "GroupName", + "Terraform": "group_name", + "Required": true + }, + { + "ROS": "GroupType", + "Terraform": "group_type", + "Required": true + }, + { + "ROS": null, + "Terraform": "lang", + "Required": false + }, + { + "ROS": "RegionId", + "Terraform": null, + "Required": false + }, + { + "ROS": "TagRelation", + "Terraform": "tag_relation", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "GroupUuid", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CLOUDFW::AllFwSwitch", + "Terraform": null + }, + "ProductCode": "cfw", + "Name": { + "zh": "CLOUDFW AllFwSwitch", + "en": "All Firewall Switches" + }, + "Properties": [ + { + "ROS": "InstanceId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CLOUDFW::Instance" + } + ] + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CLOUDFW::ControlPolicy", + "Terraform": "alicloud_cloud_firewall_control_policy" + }, + "ProductCode": "cfw", + "Name": { + "zh": "云防火墙访问控制策略", + "en": "Cloud Firewall Access Control Policy" + }, + "Properties": [ + { + "ROS": "AclAction", + "Terraform": "acl_action", + "Required": true + }, + { + "ROS": "ApplicationName", + "Terraform": "application_name", + "Required": false + }, + { + "ROS": "ApplicationNameList", + "Terraform": "application_name_list", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": true + }, + { + "ROS": "Destination", + "Terraform": "destination", + "Required": true + }, + { + "ROS": "DestinationType", + "Terraform": "destination_type", + "Required": true + }, + { + "ROS": "DestPort", + "Terraform": "dest_port", + "Required": false + }, + { + "ROS": "DestPortGroup", + "Terraform": "dest_port_group", + "Required": false + }, + { + "ROS": "DestPortType", + "Terraform": "dest_port_type", + "Required": false + }, + { + "ROS": "Direction", + "Terraform": "direction", + "Required": true + }, + { + "ROS": "DomainResolveType", + "Terraform": "domain_resolve_type", + "Required": false + }, + { + "ROS": "EndTime", + "Terraform": "end_time", + "Required": false + }, + { + "ROS": "IpVersion", + "Terraform": "ip_version", + "Required": false + }, + { + "ROS": null, + "Terraform": "lang", + "Required": false + }, + { + "ROS": "NewOrder", + "Terraform": null, + "Required": true + }, + { + "ROS": "Proto", + "Terraform": "proto", + "Required": true + }, + { + "ROS": "RegionId", + "Terraform": null, + "Required": false + }, + { + "ROS": "Release", + "Terraform": "release", + "Required": false + }, + { + "ROS": "RepeatDays", + "Terraform": "repeat_days", + "Required": false + }, + { + "ROS": "RepeatEndTime", + "Terraform": "repeat_end_time", + "Required": false + }, + { + "ROS": "RepeatStartTime", + "Terraform": "repeat_start_time", + "Required": false + }, + { + "ROS": "RepeatType", + "Terraform": "repeat_type", + "Required": false + }, + { + "ROS": "Source", + "Terraform": "source", + "Required": true + }, + { + "ROS": null, + "Terraform": "source_ip", + "Required": false + }, + { + "ROS": "SourceType", + "Terraform": "source_type", + "Required": true + }, + { + "ROS": "StartTime", + "Terraform": "start_time", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "AclUuid", + "Terraform": "acl_uuid" + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "AclUuid", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CLOUDFW::FwSwitch", + "Terraform": null + }, + "ProductCode": "cfw", + "Name": { + "zh": "CLOUDFW FwSwitch", + "en": "Firewall Switch" + }, + "Properties": [ + { + "ROS": "IpaddrList", + "Terraform": null, + "Required": false + }, + { + "ROS": "RegionList", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceTypeList", + "Terraform": null, + "Required": false + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CLOUDFW::Instance", + "Terraform": "alicloud_cloud_firewall_instance" + }, + "ProductCode": "cfw", + "Name": { + "zh": "云防火墙实例", + "en": "Cloud Firewall Instance" + }, + "Properties": [ + { + "ROS": "AccountNum", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "account_number", + "Required": false + }, + { + "ROS": "AclExtension", + "Terraform": null, + "Required": false + }, + { + "ROS": "AutoPay", + "Terraform": null, + "Required": false + }, + { + "ROS": "AutoRenew", + "Terraform": null, + "Required": false + }, + { + "ROS": "Bandwidth", + "Terraform": "band_width", + "Required": false + }, + { + "ROS": null, + "Terraform": "cfw_account", + "Required": false + }, + { + "ROS": null, + "Terraform": "cfw_log", + "Required": false + }, + { + "ROS": null, + "Terraform": "cfw_log_storage", + "Required": false + }, + { + "ROS": null, + "Terraform": "cfw_service", + "Required": false + }, + { + "ROS": null, + "Terraform": "fw_vpc_number", + "Required": false + }, + { + "ROS": "IgnoreExisting", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_count", + "Required": false + }, + { + "ROS": "IpNum", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "ip_number", + "Required": false + }, + { + "ROS": "LogAnalysis", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "logistics", + "Required": false + }, + { + "ROS": "LogStorage", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "modify_type", + "Required": false + }, + { + "ROS": "MultiAccountManagement", + "Terraform": null, + "Required": false + }, + { + "ROS": "NatBandwidth", + "Terraform": null, + "Required": false + }, + { + "ROS": "NatFirewallNum", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": "PayType", + "Terraform": null, + "Required": true + }, + { + "ROS": "Period", + "Terraform": "period", + "Required": false + }, + { + "ROS": "PeriodUnit", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "renewal_duration", + "Required": false + }, + { + "ROS": null, + "Terraform": "renewal_duration_unit", + "Required": false + }, + { + "ROS": null, + "Terraform": "renewal_status", + "Required": false + }, + { + "ROS": "Spec", + "Terraform": "spec", + "Required": false + }, + { + "ROS": "VpcBandwidth", + "Terraform": null, + "Required": false + }, + { + "ROS": "VpcFirewallNum", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "end_time" + }, + { + "ROS": "InstanceId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "InstanceId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "release_time" + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": null, + "Terraform": "user_status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CLOUDFW::NatFirewallControlPolicy", + "Terraform": "alicloud_cloud_firewall_nat_firewall_control_policy" + }, + "ProductCode": "cfw", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "AclAction", + "Terraform": "acl_action", + "Required": true + }, + { + "ROS": "ApplicationNameList", + "Terraform": "application_name_list", + "Required": true + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": true + }, + { + "ROS": "Destination", + "Terraform": "destination", + "Required": true + }, + { + "ROS": "DestinationType", + "Terraform": "destination_type", + "Required": true + }, + { + "ROS": "DestPort", + "Terraform": "dest_port", + "Required": false + }, + { + "ROS": "DestPortGroup", + "Terraform": "dest_port_group", + "Required": false + }, + { + "ROS": "DestPortType", + "Terraform": "dest_port_type", + "Required": false + }, + { + "ROS": "Direction", + "Terraform": "direction", + "Required": true + }, + { + "ROS": "DomainResolveType", + "Terraform": "domain_resolve_type", + "Required": false + }, + { + "ROS": "EndTime", + "Terraform": "end_time", + "Required": false + }, + { + "ROS": "IpVersion", + "Terraform": "ip_version", + "Required": false + }, + { + "ROS": "NatGatewayId", + "Terraform": "nat_gateway_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::NatGateway" + } + ] + }, + { + "ROS": "NewOrder", + "Terraform": "new_order", + "Required": true + }, + { + "ROS": "Proto", + "Terraform": "proto", + "Required": true + }, + { + "ROS": "Release", + "Terraform": "release", + "Required": false + }, + { + "ROS": "RepeatDays", + "Terraform": "repeat_days", + "Required": false + }, + { + "ROS": "RepeatEndTime", + "Terraform": "repeat_end_time", + "Required": false + }, + { + "ROS": "RepeatStartTime", + "Terraform": "repeat_start_time", + "Required": false + }, + { + "ROS": "RepeatType", + "Terraform": "repeat_type", + "Required": false + }, + { + "ROS": "Source", + "Terraform": "source", + "Required": true + }, + { + "ROS": "SourceType", + "Terraform": "source_type", + "Required": true + }, + { + "ROS": "StartTime", + "Terraform": "start_time", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "AclUuid", + "Terraform": "acl_uuid" + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "Direction", + "Terraform": null + }, + { + "ROS": "AclUuid", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "NatGatewayId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CLOUDFW::TrFirewall", + "Terraform": null + }, + "ProductCode": "cfw", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "CenId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::CenInstance" + } + ] + }, + { + "ROS": "FirewallDescription", + "Terraform": null, + "Required": false + }, + { + "ROS": "FirewallName", + "Terraform": null, + "Required": true + }, + { + "ROS": "FirewallSubnetCidr", + "Terraform": null, + "Required": false + }, + { + "ROS": "FirewallVpcCidr", + "Terraform": null, + "Required": false + }, + { + "ROS": "FirewallVpcId", + "Terraform": null, + "Required": false + }, + { + "ROS": "FirewallVswitchId", + "Terraform": null, + "Required": false + }, + { + "ROS": "RegionNo", + "Terraform": null, + "Required": true + }, + { + "ROS": "RouteMode", + "Terraform": null, + "Required": true + }, + { + "ROS": "TransitRouterId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::TransitRouter" + } + ] + }, + { + "ROS": "TrAttachmentMasterCidr", + "Terraform": null, + "Required": false + }, + { + "ROS": "TrAttachmentMasterZone", + "Terraform": null, + "Required": false + }, + { + "ROS": "TrAttachmentSlaveCidr", + "Terraform": null, + "Required": false + }, + { + "ROS": "TrAttachmentSlaveZone", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "FirewallId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CLOUDFW::TrFirewallRoutePolicy", + "Terraform": null + }, + "ProductCode": "cfw", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "DestCandidateList", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "CandidateId", + "Terraform": null, + "Required": true + }, + { + "ROS": "CandidateType", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "FirewallId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CLOUDFW::TrFirewall" + } + ] + }, + { + "ROS": "PolicyDescription", + "Terraform": null, + "Required": true + }, + { + "ROS": "PolicyName", + "Terraform": null, + "Required": true + }, + { + "ROS": "PolicyType", + "Terraform": null, + "Required": true + }, + { + "ROS": "SrcCandidateList", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "CandidateId", + "Terraform": null, + "Required": true + }, + { + "ROS": "CandidateType", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "FirewallId", + "Terraform": null + }, + { + "ROS": "TrFirewallRoutePolicyId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CLOUDFW::VpcFirewallCen", + "Terraform": "alicloud_cloud_firewall_vpc_firewall_cen" + }, + "ProductCode": "cfw", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "CenId", + "Terraform": "cen_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::CenInstance" + } + ] + }, + { + "ROS": "FirewallSwitch", + "Terraform": null, + "Required": true + }, + { + "ROS": "FirewallVpcCidrBlock", + "Terraform": null, + "Required": false + }, + { + "ROS": "FirewallVpcZoneId", + "Terraform": null, + "Required": true + }, + { + "ROS": "FirewallVSwitchCidrBlock", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "lang", + "Required": false + }, + { + "ROS": null, + "Terraform": "local_vpc", + "Required": false + }, + { + "ROS": "MemberUid", + "Terraform": "member_uid", + "Required": false + }, + { + "ROS": "NetworkInstanceId", + "Terraform": null, + "Required": true + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": "VpcFirewallName", + "Terraform": "vpc_firewall_name", + "Required": true + }, + { + "ROS": "VpcRegion", + "Terraform": "vpc_region", + "Required": true + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "connect_type" + }, + { + "ROS": "VpcFirewallId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "local_vpc" + }, + { + "ROS": "VpcFirewallId", + "Terraform": "vpc_firewall_id" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CLOUDFW::VpcFirewallConfigure", + "Terraform": null + }, + "ProductCode": "cfw", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "FirewallSwitch", + "Terraform": null, + "Required": true + }, + { + "ROS": "LocalVpcCidrTableList", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "RouteEntryList", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "DestinationCidr", + "Terraform": null, + "Required": true + }, + { + "ROS": "NextHopInstanceId", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "RouteTableId", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "LocalVpcId", + "Terraform": null, + "Required": true + }, + { + "ROS": "LocalVpcRegion", + "Terraform": null, + "Required": true + }, + { + "ROS": "MemberUid", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::Account" + } + ] + }, + { + "ROS": "PeerVpcCidrTableList", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "RouteEntryList", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "DestinationCidr", + "Terraform": null, + "Required": true + }, + { + "ROS": "NextHopInstanceId", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "RouteTableId", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "PeerVpcId", + "Terraform": null, + "Required": true + }, + { + "ROS": "PeerVpcRegion", + "Terraform": null, + "Required": true + }, + { + "ROS": "VpcFirewallName", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "VpcFirewallId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CLOUDFW::VpcFirewallControlPolicy", + "Terraform": "alicloud_cloud_firewall_vpc_firewall_control_policy" + }, + "ProductCode": "cfw", + "Name": { + "zh": "VPC边界防火墙策略", + "en": "VPC Firewall Policy" + }, + "Properties": [ + { + "ROS": "AclAction", + "Terraform": "acl_action", + "Required": true + }, + { + "ROS": "ApplicationName", + "Terraform": "application_name", + "Required": false + }, + { + "ROS": "ApplicationNameList", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": true + }, + { + "ROS": "Destination", + "Terraform": "destination", + "Required": true + }, + { + "ROS": "DestinationType", + "Terraform": "destination_type", + "Required": true + }, + { + "ROS": "DestPort", + "Terraform": "dest_port", + "Required": false + }, + { + "ROS": "DestPortGroup", + "Terraform": "dest_port_group", + "Required": false + }, + { + "ROS": "DestPortType", + "Terraform": "dest_port_type", + "Required": false + }, + { + "ROS": "EndTime", + "Terraform": null, + "Required": false + }, + { + "ROS": "Lang", + "Terraform": "lang", + "Required": false + }, + { + "ROS": "MemberUid", + "Terraform": "member_uid", + "Required": false + }, + { + "ROS": "NewOrder", + "Terraform": null, + "Required": true + }, + { + "ROS": null, + "Terraform": "order", + "Required": false + }, + { + "ROS": "Proto", + "Terraform": "proto", + "Required": true + }, + { + "ROS": "RegionId", + "Terraform": null, + "Required": false + }, + { + "ROS": "Release", + "Terraform": "release", + "Required": false + }, + { + "ROS": "RepeatDays", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "RepeatEndTime", + "Terraform": null, + "Required": false + }, + { + "ROS": "RepeatStartTime", + "Terraform": null, + "Required": false + }, + { + "ROS": "RepeatType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Source", + "Terraform": "source", + "Required": true + }, + { + "ROS": "SourceType", + "Terraform": "source_type", + "Required": true + }, + { + "ROS": "StartTime", + "Terraform": null, + "Required": false + }, + { + "ROS": "VpcFirewallId", + "Terraform": "vpc_firewall_id", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "AclUuid", + "Terraform": "acl_uuid" + }, + { + "ROS": null, + "Terraform": "application_id" + }, + { + "ROS": null, + "Terraform": "destination_group_cidrs" + }, + { + "ROS": null, + "Terraform": "destination_group_type" + }, + { + "ROS": null, + "Terraform": "dest_port_group_ports" + }, + { + "ROS": null, + "Terraform": "hit_times" + }, + { + "ROS": "AclUuid", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "source_group_cidrs" + }, + { + "ROS": null, + "Terraform": "source_group_type" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CMS::Contact", + "Terraform": "alicloud_cms_alarm_contact" + }, + "ProductCode": "cms", + "Name": { + "zh": "CMS报警联系人", + "en": "CloudMonitor Contact" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "alarm_contact_name", + "Required": false + }, + { + "ROS": "Channels", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "AliIM", + "Terraform": null, + "Required": false + }, + { + "ROS": "DingWebHook", + "Terraform": null, + "Required": false + }, + { + "ROS": "Mail", + "Terraform": null, + "Required": false + }, + { + "ROS": "SMS", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": null, + "Terraform": "channels_aliim", + "Required": false + }, + { + "ROS": null, + "Terraform": "channels_ding_web_hook", + "Required": false + }, + { + "ROS": null, + "Terraform": "channels_mail", + "Required": false + }, + { + "ROS": null, + "Terraform": "channels_sms", + "Required": false + }, + { + "ROS": "ContactName", + "Terraform": null, + "Required": true + }, + { + "ROS": "Describe", + "Terraform": "describe", + "Required": true + }, + { + "ROS": null, + "Terraform": "lang", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "ContactName", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CMS::ContactGroup", + "Terraform": "alicloud_cms_alarm_contact_group" + }, + "ProductCode": "cms", + "Name": { + "zh": "CMS报警联系人组", + "en": "CloudMonitor Contact Group" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "alarm_contact_group_name", + "Required": false + }, + { + "ROS": "ContactGroupName", + "Terraform": null, + "Required": true + }, + { + "ROS": "ContactNames", + "Terraform": null, + "Required": true, + "Properties": {}, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CMS::Contact" + } + ], + "Type": "list" + }, + { + "ROS": null, + "Terraform": "contacts", + "Required": false + }, + { + "ROS": "Describe", + "Terraform": "describe", + "Required": true + }, + { + "ROS": null, + "Terraform": "enable_subscribed", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "ContactGroupName", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CMS::DynamicTagGroup", + "Terraform": "alicloud_cms_dynamic_tag_group" + }, + "ProductCode": "cms", + "Name": { + "zh": "CMS DynamicTagGroup", + "en": "CloudMonitor Dynamic Group by Tag" + }, + "Properties": [ + { + "ROS": "ContactGroupList", + "Terraform": "contact_group_list", + "Required": true + }, + { + "ROS": "EnableInstallAgent", + "Terraform": null, + "Required": false + }, + { + "ROS": "EnableSubscribeEvent", + "Terraform": null, + "Required": false + }, + { + "ROS": "MatchExpress", + "Terraform": "match_express", + "Required": false, + "Properties": [ + { + "ROS": "TagValue", + "Terraform": "tag_value", + "Required": true + }, + { + "ROS": "TagValueMatchFunction", + "Terraform": "tag_value_match_function", + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "MatchExpressFilterRelation", + "Terraform": "match_express_filter_relation", + "Required": false + }, + { + "ROS": "TagKey", + "Terraform": "tag_key", + "Required": true + }, + { + "ROS": "TemplateIdList", + "Terraform": "template_id_list", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "DynamicTagRuleId", + "Terraform": null + }, + { + "ROS": "DynamicTagRuleId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "TagKey", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CMS::EventRule", + "Terraform": "alicloud_cms_event_rule" + }, + "ProductCode": "cms", + "Name": { + "zh": "CMS EventRule", + "en": "CloudMonitor Event Rule" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "contact_parameters", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "EventPattern", + "Terraform": "event_pattern", + "Required": true, + "Properties": [ + { + "ROS": "EventTypeList", + "Terraform": "event_type_list", + "Required": false + }, + { + "ROS": "LevelList", + "Terraform": "level_list", + "Required": false + }, + { + "ROS": "NameList", + "Terraform": "name_list", + "Required": false + }, + { + "ROS": "Product", + "Terraform": "product", + "Required": false + }, + { + "ROS": null, + "Terraform": "sql_filter", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "EventType", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "fc_parameters", + "Required": false + }, + { + "ROS": "GroupId", + "Terraform": "group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CMS::MonitorGroup" + }, + { + "ResourceType": "ROS/ALIYUN::CMS::MonitorGroupInstances" + } + ] + }, + { + "ROS": null, + "Terraform": "mns_parameters", + "Required": false + }, + { + "ROS": null, + "Terraform": "open_api_parameters", + "Required": false + }, + { + "ROS": "RuleName", + "Terraform": "rule_name", + "Required": true + }, + { + "ROS": null, + "Terraform": "silence_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "sls_parameters", + "Required": false + }, + { + "ROS": "State", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": null, + "Terraform": "webhook_parameters", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Data", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "fc_parameters" + }, + { + "ROS": "Data", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "mns_parameters" + }, + { + "ROS": null, + "Terraform": "open_api_parameters" + }, + { + "ROS": null, + "Terraform": "sls_parameters" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CMS::EventRuleTargets", + "Terraform": null + }, + "ProductCode": "cms", + "Name": { + "zh": "CMS EventRuleTargets", + "en": "CloudMonitor Event Rule Recipients" + }, + "Properties": [ + { + "ROS": "ContactParameters", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "ContactGroupName", + "Terraform": null, + "Required": false + }, + { + "ROS": "Id", + "Terraform": null, + "Required": false + }, + { + "ROS": "Level", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "FcParameters", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "FunctionName", + "Terraform": null, + "Required": false + }, + { + "ROS": "Id", + "Terraform": null, + "Required": false + }, + { + "ROS": "Region", + "Terraform": null, + "Required": false + }, + { + "ROS": "ServiceName", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "MnsParameters", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Id", + "Terraform": null, + "Required": false + }, + { + "ROS": "Queue", + "Terraform": null, + "Required": false + }, + { + "ROS": "Region", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "RuleName", + "Terraform": null, + "Required": true + }, + { + "ROS": "SlsParameters", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Id", + "Terraform": null, + "Required": false + }, + { + "ROS": "LogStore", + "Terraform": null, + "Required": false + }, + { + "ROS": "Project", + "Terraform": null, + "Required": false + }, + { + "ROS": "Region", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "WebhookParameters", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Id", + "Terraform": null, + "Required": false + }, + { + "ROS": "Method", + "Terraform": null, + "Required": false + }, + { + "ROS": "Protocol", + "Terraform": null, + "Required": false + }, + { + "ROS": "Url", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CMS::GroupMetricRule", + "Terraform": "alicloud_cms_group_metric_rule" + }, + "ProductCode": "cms", + "Name": { + "zh": "CMS应用分组报警规则", + "en": "CloudMonitor Application Group Alert Rule" + }, + "Properties": [ + { + "ROS": "Category", + "Terraform": "category", + "Required": true + }, + { + "ROS": null, + "Terraform": "contact_groups", + "Required": false + }, + { + "ROS": "Dimensions", + "Terraform": "dimensions", + "Required": false + }, + { + "ROS": "EffectiveInterval", + "Terraform": "effective_interval", + "Required": false + }, + { + "ROS": "EmailSubject", + "Terraform": "email_subject", + "Required": false + }, + { + "ROS": "Escalations", + "Terraform": "escalations", + "Required": true + }, + { + "ROS": "GroupId", + "Terraform": "group_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CMS::MonitorGroup" + }, + { + "ResourceType": "ROS/ALIYUN::CMS::MonitorGroupInstances" + } + ] + }, + { + "ROS": null, + "Terraform": "group_metric_rule_name", + "Required": false + }, + { + "ROS": "Interval", + "Terraform": "interval", + "Required": false + }, + { + "ROS": "MetricName", + "Terraform": "metric_name", + "Required": true + }, + { + "ROS": "Namespace", + "Terraform": "namespace", + "Required": true + }, + { + "ROS": "NoEffectiveInterval", + "Terraform": "no_effective_interval", + "Required": false + }, + { + "ROS": "Period", + "Terraform": "period", + "Required": false + }, + { + "ROS": "RuleId", + "Terraform": "rule_id", + "Required": true + }, + { + "ROS": "RuleName", + "Terraform": null, + "Required": true + }, + { + "ROS": "SilenceTime", + "Terraform": "silence_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "targets", + "Required": false + }, + { + "ROS": "Webhook", + "Terraform": "webhook", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "RuleId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CMS::MetricRuleTargets", + "Terraform": null + }, + "ProductCode": "cms", + "Name": { + "zh": "CMS MetricRuleTargets", + "en": "CloudMonitor Alert Rule Resources" + }, + "Properties": [ + { + "ROS": "RuleId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CMS::GroupMetricRule" + } + ] + }, + { + "ROS": "Targets", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "Arn", + "Terraform": null, + "Required": true + }, + { + "ROS": "Id", + "Terraform": null, + "Required": true + }, + { + "ROS": "Level", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "Arns", + "Terraform": null + }, + { + "ROS": "Ids", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CMS::MetricRuleTemplate", + "Terraform": "alicloud_cms_metric_rule_template" + }, + "ProductCode": "cms", + "Name": { + "zh": "CMS MetricRuleTemplate", + "en": "CloudMonitor Alert Template" + }, + "Properties": [ + { + "ROS": "AlertTemplates", + "Terraform": "alert_templates", + "Required": false, + "Properties": [ + { + "ROS": "Category", + "Terraform": "category", + "Required": true + }, + { + "ROS": "Escalations", + "Terraform": "escalations", + "Required": false + }, + { + "ROS": "MetricName", + "Terraform": "metric_name", + "Required": true + }, + { + "ROS": "Namespace", + "Terraform": "namespace", + "Required": true + }, + { + "ROS": "RuleName", + "Terraform": "rule_name", + "Required": true + }, + { + "ROS": "Webhook", + "Terraform": "webhook", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": null, + "Terraform": "apply_mode", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "enable_end_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "enable_start_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CMS::MonitorGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "metric_rule_template_name", + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": null, + "Terraform": "notify_level", + "Required": false + }, + { + "ROS": "RestVersion", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "silence_time", + "Required": false + }, + { + "ROS": "TemplateId", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "webhook", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Id", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "rest_version" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CMS::MonitorGroup", + "Terraform": "alicloud_cms_monitor_group" + }, + "ProductCode": "cms", + "Name": { + "zh": "CMS应用分组", + "en": "CloudMonitor Application Group" + }, + "Properties": [ + { + "ROS": "ContactGroups", + "Terraform": "contact_groups", + "Required": false + }, + { + "ROS": "GroupName", + "Terraform": null, + "Required": true + }, + { + "ROS": null, + "Terraform": "monitor_group_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "resource_group_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "GroupId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CMS::MonitorGroupInstances", + "Terraform": "alicloud_cms_monitor_group_instances" + }, + "ProductCode": "cms", + "Name": { + "zh": "CMS MonitorGroupInstances", + "en": "CloudMonitor Application Group Instances" + }, + "Properties": [ + { + "ROS": "GroupId", + "Terraform": "group_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CMS::MonitorGroup" + } + ] + }, + { + "ROS": "Instances", + "Terraform": "instances", + "Required": true, + "Properties": [ + { + "ROS": "Category", + "Terraform": "category", + "Required": true + }, + { + "ROS": "InstanceId", + "Terraform": "instance_id", + "Required": true + }, + { + "ROS": "InstanceName", + "Terraform": "instance_name", + "Required": true + }, + { + "ROS": "RegionId", + "Terraform": "region_id", + "Required": true + } + ], + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "GroupId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CMS::MonitoringAgent", + "Terraform": null + }, + "ProductCode": "cms", + "Name": { + "zh": "CMS MonitoringAgent", + "en": "CloudMonitor Agent" + }, + "Properties": [ + { + "ROS": "Force", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstallCommand", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceIds", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Instance" + }, + { + "ResourceType": "ROS/ALIYUN::ECS::InstanceGroup" + } + ] + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CMS::MonitoringAgentProcess", + "Terraform": "alicloud_cloud_monitor_service_monitoring_agent_process" + }, + "ProductCode": "cms", + "Name": { + "zh": "CMS MonitoringAgentProcess", + "en": "CloudMonitor Process Monitoring Task" + }, + "Properties": [ + { + "ROS": "InstanceId", + "Terraform": "instance_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Instance" + }, + { + "ResourceType": "ROS/ALIYUN::ECS::InstanceGroup" + } + ] + }, + { + "ROS": "ProcessName", + "Terraform": "process_name", + "Required": false + }, + { + "ROS": "ProcessUser", + "Terraform": "process_user", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Id", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "process_id" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CMS::Namespace", + "Terraform": "alicloud_cms_namespace" + }, + "ProductCode": "cms", + "Name": { + "zh": "CMS Namespace", + "en": "CloudMonitor Namespace" + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "Namespace", + "Terraform": "namespace", + "Required": true + }, + { + "ROS": "Specification", + "Terraform": "specification", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "CreateTime", + "Terraform": null + }, + { + "ROS": "Description", + "Terraform": null + }, + { + "ROS": "Namespace", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "ModifyTime", + "Terraform": null + }, + { + "ROS": "Specification", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CMS::ResourceMetricRule", + "Terraform": null + }, + "ProductCode": "cms", + "Name": { + "zh": "CMS ResourceMetricRule", + "en": "CloudMonitor Resource Alert Rule" + }, + "Properties": [ + { + "ROS": "CompositeExpression", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "ExpressionList", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "ComparisonOperator", + "Terraform": null, + "Required": true + }, + { + "ROS": "MetricName", + "Terraform": null, + "Required": true + }, + { + "ROS": "Period", + "Terraform": null, + "Required": true + }, + { + "ROS": "Statistics", + "Terraform": null, + "Required": true + }, + { + "ROS": "Threshold", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "ExpressionListJoin", + "Terraform": null, + "Required": false + }, + { + "ROS": "ExpressionRaw", + "Terraform": null, + "Required": false + }, + { + "ROS": "Level", + "Terraform": null, + "Required": true + }, + { + "ROS": "Times", + "Terraform": null, + "Required": true + } + ] + }, + { + "ROS": "ContactGroups", + "Terraform": null, + "Required": true, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "DeletionForce", + "Terraform": null, + "Required": false + }, + { + "ROS": "EffectiveInterval", + "Terraform": null, + "Required": false + }, + { + "ROS": "EmailSubject", + "Terraform": null, + "Required": false + }, + { + "ROS": "Escalations", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "Critical", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "ComparisonOperator", + "Terraform": null, + "Required": true + }, + { + "ROS": "Statistics", + "Terraform": null, + "Required": true + }, + { + "ROS": "Threshold", + "Terraform": null, + "Required": true + }, + { + "ROS": "Times", + "Terraform": null, + "Required": true + } + ] + }, + { + "ROS": "Info", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "ComparisonOperator", + "Terraform": null, + "Required": true + }, + { + "ROS": "Statistics", + "Terraform": null, + "Required": true + }, + { + "ROS": "Threshold", + "Terraform": null, + "Required": true + }, + { + "ROS": "Times", + "Terraform": null, + "Required": true + } + ] + }, + { + "ROS": "Warn", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "ComparisonOperator", + "Terraform": null, + "Required": true + }, + { + "ROS": "Statistics", + "Terraform": null, + "Required": true + }, + { + "ROS": "Threshold", + "Terraform": null, + "Required": true + }, + { + "ROS": "Times", + "Terraform": null, + "Required": true + } + ] + } + ] + }, + { + "ROS": "Interval", + "Terraform": null, + "Required": false + }, + { + "ROS": "Labels", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "MetricName", + "Terraform": null, + "Required": true + }, + { + "ROS": "Namespace", + "Terraform": null, + "Required": true + }, + { + "ROS": "NoDataPolicy", + "Terraform": null, + "Required": false + }, + { + "ROS": "NoEffectiveInterval", + "Terraform": null, + "Required": false + }, + { + "ROS": "Period", + "Terraform": null, + "Required": false + }, + { + "ROS": "Prometheus", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Annotations", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": false + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "Level", + "Terraform": null, + "Required": true + }, + { + "ROS": "PromQL", + "Terraform": null, + "Required": true + }, + { + "ROS": "Times", + "Terraform": null, + "Required": true + } + ] + }, + { + "ROS": "Resources", + "Terraform": null, + "Required": true, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "RuleId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CMS::GroupMetricRule" + } + ] + }, + { + "ROS": "RuleName", + "Terraform": null, + "Required": false + }, + { + "ROS": "SilenceTime", + "Terraform": null, + "Required": false + }, + { + "ROS": "Webhook", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "RuleId", + "Terraform": null + }, + { + "ROS": "RuleName", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CMS::SiteMonitor", + "Terraform": "alicloud_cms_site_monitor" + }, + "ProductCode": "cms", + "Name": { + "zh": "CMS SiteMonitor", + "en": "CloudMonitor Site Monitoring Task" + }, + "Properties": [ + { + "ROS": "Address", + "Terraform": "address", + "Required": true + }, + { + "ROS": "AlertIds", + "Terraform": "alert_ids", + "Required": false + }, + { + "ROS": "Interval", + "Terraform": "interval", + "Required": false + }, + { + "ROS": "IspCities", + "Terraform": "isp_cities", + "Required": false, + "Properties": [ + { + "ROS": "City", + "Terraform": "city", + "Required": true + }, + { + "ROS": "Isp", + "Terraform": "isp", + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "OptionsJson", + "Terraform": "options_json", + "Required": false + }, + { + "ROS": "TaskName", + "Terraform": "task_name", + "Required": true + }, + { + "ROS": "TaskType", + "Terraform": "task_type", + "Required": true + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "TaskId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "TaskId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "task_state" + }, + { + "ROS": null, + "Terraform": "update_time" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CMS::SlsGroup", + "Terraform": "alicloud_cms_sls_group" + }, + "ProductCode": "cms", + "Name": { + "zh": "CMS SlsGroup", + "en": "CloudMonitor SLS Logstore Group" + }, + "Properties": [ + { + "ROS": "SlsGroupConfig", + "Terraform": "sls_group_config", + "Required": true, + "Properties": [ + { + "ROS": "SlsLogstore", + "Terraform": "sls_logstore", + "Required": true + }, + { + "ROS": "SlsProject", + "Terraform": "sls_project", + "Required": true + }, + { + "ROS": "SlsRegion", + "Terraform": "sls_region", + "Required": true + }, + { + "ROS": "SlsUserId", + "Terraform": "sls_user_id", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "SlsGroupDescription", + "Terraform": "sls_group_description", + "Required": false + }, + { + "ROS": "SlsGroupName", + "Terraform": "sls_group_name", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "CreateTime", + "Terraform": null + }, + { + "ROS": "SlsGroupName", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "SlsGroupConfig", + "Terraform": null + }, + { + "ROS": "SlsGroupDescription", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CS::ASKCluster", + "Terraform": null + }, + "ProductCode": "acs", + "Name": { + "zh": "ACK Serverless集群", + "en": "ASK Cluster" + }, + "Properties": [ + { + "ROS": "Addons", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Config", + "Terraform": null, + "Required": false + }, + { + "ROS": "Disabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "ClusterSpec", + "Terraform": null, + "Required": false + }, + { + "ROS": "DeleteOptions", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "DeleteMode", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceType", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "DeletionProtection", + "Terraform": null, + "Required": false + }, + { + "ROS": "EndpointPublicAccess", + "Terraform": null, + "Required": false + }, + { + "ROS": "KubernetesVersion", + "Terraform": null, + "Required": false + }, + { + "ROS": "MaintenanceWindow", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Duration", + "Terraform": null, + "Required": false + }, + { + "ROS": "Enable", + "Terraform": null, + "Required": false + }, + { + "ROS": "MaintenanceTime", + "Terraform": null, + "Required": false + }, + { + "ROS": "Recurrence", + "Terraform": null, + "Required": false + }, + { + "ROS": "WeeklyPeriod", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "PrivateZone", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "SecurityGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "ServiceCidr", + "Terraform": null, + "Required": false + }, + { + "ROS": "ServiceDiscoveryTypes", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "SnatEntry", + "Terraform": null, + "Required": false + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "TimeZone", + "Terraform": null, + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ], + "Type": "list" + }, + { + "ROS": "ZoneId", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "APIServerSLBId", + "Terraform": null + }, + { + "ROS": "ClusterId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "DefaultUserKubeConfig", + "Terraform": null + }, + { + "ROS": "IngressSLBId", + "Terraform": null + }, + { + "ROS": "Nodes", + "Terraform": null + }, + { + "ROS": "PrivateUserKubConfig", + "Terraform": null + }, + { + "ROS": "ScalingConfigurationId", + "Terraform": null + }, + { + "ROS": "ScalingGroupId", + "Terraform": null + }, + { + "ROS": "ScalingRuleId", + "Terraform": null + }, + { + "ROS": "TaskId", + "Terraform": null + }, + { + "ROS": "WorkerRamRoleName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CS::AnyCluster", + "Terraform": null + }, + "ProductCode": "acs", + "Name": { + "zh": "容器集群", + "en": "ACK Cluster" + }, + "Properties": [ + { + "ROS": "ClusterConfig", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "APIServerSLBId", + "Terraform": null + }, + { + "ROS": "ClusterId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "DefaultUserKubeConfig", + "Terraform": null + }, + { + "ROS": "IngressSLBId", + "Terraform": null + }, + { + "ROS": "Nodes", + "Terraform": null + }, + { + "ROS": "PrivateUserKubConfig", + "Terraform": null + }, + { + "ROS": "ScalingConfigurationId", + "Terraform": null + }, + { + "ROS": "ScalingGroupId", + "Terraform": null + }, + { + "ROS": "ScalingRuleId", + "Terraform": null + }, + { + "ROS": "TaskId", + "Terraform": null + }, + { + "ROS": "WorkerRamRoleName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CS::ApplicationDeployment", + "Terraform": null + }, + "ProductCode": "acs", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "ChartUrl", + "Terraform": null, + "Required": true + }, + { + "ROS": "ClusterId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CS::ASKCluster" + }, + { + "ResourceType": "ROS/ALIYUN::CS::AnyCluster" + }, + { + "ResourceType": "ROS/ALIYUN::CS::ManagedEdgeKubernetesCluster" + }, + { + "ResourceType": "ROS/ALIYUN::CS::ManagedKubernetesCluster" + }, + { + "ResourceType": "ROS/ALIYUN::CS::KubernetesCluster" + }, + { + "ResourceType": "ROS/ALIYUN::CS::ServerlessKubernetesCluster" + } + ] + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "Namespace", + "Terraform": null, + "Required": true + }, + { + "ROS": "Type", + "Terraform": null, + "Required": true + }, + { + "ROS": "Values", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "TaskId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CS::ClusterAddons", + "Terraform": "alicloud_cs_kubernetes_addon" + }, + "ProductCode": "acs", + "Name": { + "zh": "容器组件", + "en": "ACK Cluster Components" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "cleanup_cloud_resources", + "Required": false + }, + { + "ROS": "ClusterId", + "Terraform": "cluster_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CS::ASKCluster" + }, + { + "ResourceType": "ROS/ALIYUN::CS::AnyCluster" + }, + { + "ResourceType": "ROS/ALIYUN::CS::ManagedEdgeKubernetesCluster" + }, + { + "ResourceType": "ROS/ALIYUN::CS::ManagedKubernetesCluster" + }, + { + "ResourceType": "ROS/ALIYUN::CS::KubernetesCluster" + }, + { + "ResourceType": "ROS/ALIYUN::CS::ServerlessKubernetesCluster" + } + ] + }, + { + "ROS": "Addons.Config", + "Terraform": "config", + "Required": false + }, + { + "ROS": "InstalledIgnore", + "Terraform": null, + "Required": false + }, + { + "ROS": "Addons.Name", + "Terraform": "name", + "Required": false + }, + { + "ROS": "RolePolicy", + "Terraform": null, + "Required": false + }, + { + "ROS": "ValidationMode", + "Terraform": null, + "Required": false + }, + { + "ROS": "Addons.Version", + "Terraform": "version", + "Required": false + }, + { + "ROS": "WaitUntil", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "ApiVersion", + "Terraform": null, + "Required": false + }, + { + "ROS": "FirstMatch", + "Terraform": null, + "Required": false + }, + { + "ROS": "JsonPath", + "Terraform": null, + "Required": false + }, + { + "ROS": "Kind", + "Terraform": null, + "Required": true + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "Namespace", + "Terraform": null, + "Required": false + }, + { + "ROS": "Operator", + "Terraform": null, + "Required": true + }, + { + "ROS": "Stage", + "Terraform": null, + "Required": false + }, + { + "ROS": "Timeout", + "Terraform": null, + "Required": false + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + }, + { + "ROS": "ValueType", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "can_upgrade" + }, + { + "ROS": "ClusterId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "next_version" + }, + { + "ROS": null, + "Terraform": "required" + }, + { + "ROS": "WaitUntilData", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CS::ClusterApplication", + "Terraform": null + }, + "ProductCode": "acs", + "Name": { + "zh": "容器应用部署", + "en": "Deploy Application in ACK Cluster" + }, + "Properties": [ + { + "ROS": "ClusterId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CS::ASKCluster" + }, + { + "ResourceType": "ROS/ALIYUN::CS::AnyCluster" + }, + { + "ResourceType": "ROS/ALIYUN::CS::ManagedEdgeKubernetesCluster" + }, + { + "ResourceType": "ROS/ALIYUN::CS::ManagedKubernetesCluster" + }, + { + "ResourceType": "ROS/ALIYUN::CS::KubernetesCluster" + }, + { + "ResourceType": "ROS/ALIYUN::CS::ServerlessKubernetesCluster" + } + ] + }, + { + "ROS": "DefaultNamespace", + "Terraform": null, + "Required": false + }, + { + "ROS": "RolePolicy", + "Terraform": null, + "Required": false + }, + { + "ROS": "Stage", + "Terraform": null, + "Required": false + }, + { + "ROS": "ValidationMode", + "Terraform": null, + "Required": false + }, + { + "ROS": "WaitUntil", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "ApiVersion", + "Terraform": null, + "Required": false + }, + { + "ROS": "FirstMatch", + "Terraform": null, + "Required": false + }, + { + "ROS": "JsonPath", + "Terraform": null, + "Required": false + }, + { + "ROS": "Kind", + "Terraform": null, + "Required": true + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "Namespace", + "Terraform": null, + "Required": false + }, + { + "ROS": "Operator", + "Terraform": null, + "Required": true + }, + { + "ROS": "Stage", + "Terraform": null, + "Required": false + }, + { + "ROS": "Timeout", + "Terraform": null, + "Required": false + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + }, + { + "ROS": "ValueType", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "YamlContent", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "ClusterId", + "Terraform": null + }, + { + "ROS": "WaitUntilData", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CS::ClusterHelmApplication", + "Terraform": null + }, + "ProductCode": "acs", + "Name": { + "zh": "Helm应用部署", + "en": "Use Helm to Deploy Application" + }, + "Properties": [ + { + "ROS": "ChartUrl", + "Terraform": null, + "Required": true + }, + { + "ROS": "ChartValues", + "Terraform": null, + "Required": false + }, + { + "ROS": "ClusterId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CS::ASKCluster" + }, + { + "ResourceType": "ROS/ALIYUN::CS::AnyCluster" + }, + { + "ResourceType": "ROS/ALIYUN::CS::ManagedEdgeKubernetesCluster" + }, + { + "ResourceType": "ROS/ALIYUN::CS::ManagedKubernetesCluster" + }, + { + "ResourceType": "ROS/ALIYUN::CS::KubernetesCluster" + }, + { + "ResourceType": "ROS/ALIYUN::CS::ServerlessKubernetesCluster" + } + ] + }, + { + "ROS": "Credential", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Password", + "Terraform": null, + "Required": true + }, + { + "ROS": "UserName", + "Terraform": null, + "Required": true + } + ] + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "Namespace", + "Terraform": null, + "Required": false + }, + { + "ROS": "RolePolicy", + "Terraform": null, + "Required": false + }, + { + "ROS": "ValidationMode", + "Terraform": null, + "Required": false + }, + { + "ROS": "WaitUntil", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "ApiVersion", + "Terraform": null, + "Required": false + }, + { + "ROS": "FirstMatch", + "Terraform": null, + "Required": false + }, + { + "ROS": "JsonPath", + "Terraform": null, + "Required": false + }, + { + "ROS": "Kind", + "Terraform": null, + "Required": true + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "Namespace", + "Terraform": null, + "Required": false + }, + { + "ROS": "Operator", + "Terraform": null, + "Required": true + }, + { + "ROS": "Stage", + "Terraform": null, + "Required": false + }, + { + "ROS": "Timeout", + "Terraform": null, + "Required": false + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + }, + { + "ROS": "ValueType", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "ClusterId", + "Terraform": null + }, + { + "ROS": "WaitUntilData", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CS::ClusterNodePool", + "Terraform": "alicloud_cs_kubernetes_node_pool" + }, + "ProductCode": "acs", + "Name": { + "zh": "容器节点池", + "en": "ACK Cluster Node Pool" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "auto_renew", + "Required": false + }, + { + "ROS": null, + "Terraform": "auto_renew_period", + "Required": false + }, + { + "ROS": "AutoScaling", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "EipBandwidth", + "Terraform": null, + "Required": false + }, + { + "ROS": "EipInternetChargeType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Enable", + "Terraform": null, + "Required": true + }, + { + "ROS": "IsBondEip", + "Terraform": null, + "Required": false + }, + { + "ROS": "MaxInstances", + "Terraform": null, + "Required": false + }, + { + "ROS": "MinInstances", + "Terraform": null, + "Required": false + }, + { + "ROS": "Type", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "ClusterId", + "Terraform": "cluster_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CS::ASKCluster" + }, + { + "ResourceType": "ROS/ALIYUN::CS::AnyCluster" + }, + { + "ResourceType": "ROS/ALIYUN::CS::ManagedEdgeKubernetesCluster" + }, + { + "ResourceType": "ROS/ALIYUN::CS::ManagedKubernetesCluster" + }, + { + "ResourceType": "ROS/ALIYUN::CS::KubernetesCluster" + }, + { + "ResourceType": "ROS/ALIYUN::CS::ServerlessKubernetesCluster" + } + ] + }, + { + "ROS": null, + "Terraform": "compensate_with_on_demand", + "Required": false + }, + { + "ROS": "Count", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "cpu_policy", + "Required": false + }, + { + "ROS": null, + "Terraform": "data_disks", + "Required": false + }, + { + "ROS": null, + "Terraform": "deployment_set_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::DeploymentSet" + } + ] + }, + { + "ROS": null, + "Terraform": "desired_size", + "Required": false + }, + { + "ROS": null, + "Terraform": "force_delete", + "Required": false + }, + { + "ROS": null, + "Terraform": "format_disk", + "Required": false + }, + { + "ROS": null, + "Terraform": "image_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::CustomImage" + } + ] + }, + { + "ROS": null, + "Terraform": "image_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "install_cloud_monitor", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_charge_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "instances", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_types", + "Required": false + }, + { + "ROS": null, + "Terraform": "internet_charge_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "internet_max_bandwidth_out", + "Required": false + }, + { + "ROS": null, + "Terraform": "keep_instance_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "key_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "kms_encrypted_password", + "Required": false + }, + { + "ROS": null, + "Terraform": "kms_encryption_context", + "Required": false + }, + { + "ROS": null, + "Terraform": "kubelet_configuration", + "Required": false + }, + { + "ROS": "KubernetesConfig", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "CmsEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "CpuPolicy", + "Terraform": null, + "Required": false + }, + { + "ROS": "Labels", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "NodeNameMode", + "Terraform": null, + "Required": false + }, + { + "ROS": "Runtime", + "Terraform": null, + "Required": true + }, + { + "ROS": "RuntimeVersion", + "Terraform": null, + "Required": true + }, + { + "ROS": "Taints", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Effect", + "Terraform": null, + "Required": false + }, + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "Unschedulable", + "Terraform": null, + "Required": false + }, + { + "ROS": "UserData", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": null, + "Terraform": "labels", + "Required": false + }, + { + "ROS": null, + "Terraform": "login_as_non_root", + "Required": false + }, + { + "ROS": "Management", + "Terraform": "management", + "Required": false + }, + { + "ROS": null, + "Terraform": "multi_az_policy", + "Required": false + }, + { + "ROS": null, + "Terraform": "node_name_mode", + "Required": false + }, + { + "ROS": "NodePoolInfo", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + } + ] + }, + { + "ROS": null, + "Terraform": "node_pool_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "on_demand_base_capacity", + "Required": false + }, + { + "ROS": null, + "Terraform": "on_demand_percentage_above_base_capacity", + "Required": false + }, + { + "ROS": null, + "Terraform": "password", + "Required": false + }, + { + "ROS": null, + "Terraform": "period", + "Required": false + }, + { + "ROS": null, + "Terraform": "period_unit", + "Required": false + }, + { + "ROS": null, + "Terraform": "pre_user_data", + "Required": false + }, + { + "ROS": null, + "Terraform": "private_pool_options", + "Required": false + }, + { + "ROS": null, + "Terraform": "rds_instances", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "rolling_policy", + "Required": false + }, + { + "ROS": null, + "Terraform": "runtime_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "runtime_version", + "Required": false + }, + { + "ROS": null, + "Terraform": "scaling_config", + "Required": false + }, + { + "ROS": "ScalingGroup", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "AutoRenew", + "Terraform": null, + "Required": false + }, + { + "ROS": "AutoRenewPeriod", + "Terraform": null, + "Required": false + }, + { + "ROS": "CompensateWithOnDemand", + "Terraform": null, + "Required": false + }, + { + "ROS": "DataDisks", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "AutoSnapshotPolicyId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::AutoSnapshotPolicy" + } + ] + }, + { + "ROS": "Category", + "Terraform": null, + "Required": false + }, + { + "ROS": "Encrypted", + "Terraform": null, + "Required": false + }, + { + "ROS": "PerformanceLevel", + "Terraform": null, + "Required": false + }, + { + "ROS": "Size", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "ImageId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::CustomImage" + } + ] + }, + { + "ROS": "InstanceChargeType", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceTypes", + "Terraform": null, + "Required": true, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "InternetChargeType", + "Terraform": null, + "Required": false + }, + { + "ROS": "InternetMaxBandwidthOut", + "Terraform": null, + "Required": false + }, + { + "ROS": "KeyPair", + "Terraform": null, + "Required": false + }, + { + "ROS": "LoginPassword", + "Terraform": null, + "Required": false + }, + { + "ROS": "MultiAzPolicy", + "Terraform": null, + "Required": false + }, + { + "ROS": "OnDemandBaseCapacity", + "Terraform": null, + "Required": false + }, + { + "ROS": "OnDemandPercentageAboveBaseCapacity", + "Terraform": null, + "Required": false + }, + { + "ROS": "Period", + "Terraform": null, + "Required": false + }, + { + "ROS": "PeriodUnit", + "Terraform": null, + "Required": false + }, + { + "ROS": "Platform", + "Terraform": null, + "Required": false + }, + { + "ROS": "RdsInstances", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "ScalingPolicy", + "Terraform": null, + "Required": false + }, + { + "ROS": "SecurityGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "SpotInstancePools", + "Terraform": null, + "Required": false + }, + { + "ROS": "SpotInstanceRemedy", + "Terraform": null, + "Required": false + }, + { + "ROS": "SpotPriceLimit", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "InstanceType", + "Terraform": null, + "Required": true + }, + { + "ROS": "PriceLimit", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "SpotStrategy", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskCategory", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskPerformanceLevel", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskSize", + "Terraform": null, + "Required": true + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "VSwitchIds", + "Terraform": null, + "Required": true, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "ZoneIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + } + ] + }, + { + "ROS": null, + "Terraform": "scaling_policy", + "Required": false + }, + { + "ROS": null, + "Terraform": "security_group_ids", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "security_hardening_os", + "Required": false + }, + { + "ROS": null, + "Terraform": "soc_enabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "spot_instance_pools", + "Required": false + }, + { + "ROS": null, + "Terraform": "spot_instance_remedy", + "Required": false + }, + { + "ROS": null, + "Terraform": "spot_price_limit", + "Required": false + }, + { + "ROS": null, + "Terraform": "spot_strategy", + "Required": false + }, + { + "ROS": null, + "Terraform": "system_disk_bursting_enabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "system_disk_categories", + "Required": false + }, + { + "ROS": null, + "Terraform": "system_disk_category", + "Required": false + }, + { + "ROS": null, + "Terraform": "system_disk_encrypt_algorithm", + "Required": false + }, + { + "ROS": null, + "Terraform": "system_disk_encrypted", + "Required": false + }, + { + "ROS": null, + "Terraform": "system_disk_kms_key", + "Required": false + }, + { + "ROS": null, + "Terraform": "system_disk_performance_level", + "Required": false + }, + { + "ROS": null, + "Terraform": "system_disk_provisioned_iops", + "Required": false + }, + { + "ROS": null, + "Terraform": "system_disk_size", + "Required": false + }, + { + "ROS": null, + "Terraform": "system_disk_snapshot_policy_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": null, + "Terraform": "taints", + "Required": false + }, + { + "ROS": "TeeConfig", + "Terraform": "tee_config", + "Required": false + }, + { + "ROS": null, + "Terraform": "unschedulable", + "Required": false + }, + { + "ROS": null, + "Terraform": "update_nodes", + "Required": false + }, + { + "ROS": null, + "Terraform": "user_data", + "Required": false + }, + { + "ROS": null, + "Terraform": "vswitch_ids", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "NodePoolId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "NodePoolId", + "Terraform": "node_pool_id" + }, + { + "ROS": null, + "Terraform": "scaling_group_id" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CS::GrantPermissions", + "Terraform": null + }, + "ProductCode": "acs", + "Name": { + "zh": "CS GrantPermissions", + "en": "Grant Permissions" + }, + "Properties": [ + { + "ROS": "Permissions", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "ClusterId", + "Terraform": null, + "Required": true + }, + { + "ROS": "IsCustom", + "Terraform": null, + "Required": false + }, + { + "ROS": "IsRamRole", + "Terraform": null, + "Required": false + }, + { + "ROS": "Namespace", + "Terraform": null, + "Required": false + }, + { + "ROS": "RoleName", + "Terraform": null, + "Required": true + }, + { + "ROS": "RoleType", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "UserId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ALIYUN::CR::UserInfo" + } + ] + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CS::KubernetesCluster", + "Terraform": "alicloud_cs_kubernetes" + }, + "ProductCode": "acs", + "Name": { + "zh": "Kubernetes集群", + "en": "Kubernetes Cluster" + }, + "Properties": [ + { + "ROS": "Addons", + "Terraform": "addons", + "Required": false, + "Properties": [ + { + "ROS": "Config", + "Terraform": "config", + "Required": false + }, + { + "ROS": "Disabled", + "Terraform": "disabled", + "Required": false + }, + { + "ROS": "Name", + "Terraform": "name", + "Required": true + }, + { + "ROS": null, + "Terraform": "version", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": null, + "Terraform": "api_audiences", + "Required": false + }, + { + "ROS": null, + "Terraform": "availability_zone", + "Required": false + }, + { + "ROS": null, + "Terraform": "client_cert", + "Required": false + }, + { + "ROS": null, + "Terraform": "client_key", + "Required": false + }, + { + "ROS": null, + "Terraform": "cluster_ca_cert", + "Required": false + }, + { + "ROS": null, + "Terraform": "cluster_domain", + "Required": false + }, + { + "ROS": null, + "Terraform": "cluster_network_type", + "Required": false + }, + { + "ROS": "ContainerCidr", + "Terraform": null, + "Required": false + }, + { + "ROS": "ControlPlaneLogComponents", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "ControlPlaneLogProject", + "Terraform": null, + "Required": false + }, + { + "ROS": "ControlPlaneLogTtl", + "Terraform": null, + "Required": false + }, + { + "ROS": "CpuPolicy", + "Terraform": "cpu_policy", + "Required": false + }, + { + "ROS": null, + "Terraform": "custom_san", + "Required": false + }, + { + "ROS": "DeleteOptions", + "Terraform": "delete_options", + "Required": false, + "Properties": [ + { + "ROS": "DeleteMode", + "Terraform": "delete_mode", + "Required": false + }, + { + "ROS": "ResourceType", + "Terraform": "resource_type", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "DeletionProtection", + "Terraform": "deletion_protection", + "Required": false + }, + { + "ROS": "SshFlags", + "Terraform": "enable_ssh", + "Required": false + }, + { + "ROS": "EndpointPublicAccess", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "exclude_autoscaler_nodes", + "Required": false + }, + { + "ROS": null, + "Terraform": "force_update", + "Required": false + }, + { + "ROS": "FormatDisk", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "image_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::CustomImage" + } + ] + }, + { + "ROS": "CloudMonitorFlags", + "Terraform": "install_cloud_monitor", + "Required": false + }, + { + "ROS": "IsEnterpriseSecurityGroup", + "Terraform": "is_enterprise_security_group", + "Required": false + }, + { + "ROS": "KeepInstanceName", + "Terraform": null, + "Required": false + }, + { + "ROS": "KeyPair", + "Terraform": "key_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "kms_encrypted_password", + "Required": false + }, + { + "ROS": null, + "Terraform": "kms_encryption_context", + "Required": false + }, + { + "ROS": null, + "Terraform": "kube_config", + "Required": false + }, + { + "ROS": "LoadBalancerSpec", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "log_config", + "Required": false + }, + { + "ROS": "MasterAutoRenew", + "Terraform": "master_auto_renew", + "Required": false + }, + { + "ROS": "MasterAutoRenewPeriod", + "Terraform": "master_auto_renew_period", + "Required": false + }, + { + "ROS": "MasterCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "MasterDataDisk", + "Terraform": null, + "Required": false + }, + { + "ROS": "MasterDataDisks", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Category", + "Terraform": null, + "Required": true + }, + { + "ROS": "Size", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": null, + "Terraform": "master_disk_category", + "Required": false + }, + { + "ROS": null, + "Terraform": "master_disk_performance_level", + "Required": false + }, + { + "ROS": null, + "Terraform": "master_disk_size", + "Required": false + }, + { + "ROS": null, + "Terraform": "master_disk_snapshot_policy_id", + "Required": false + }, + { + "ROS": "MasterInstanceChargeType", + "Terraform": "master_instance_charge_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "master_instance_type", + "Required": false + }, + { + "ROS": "MasterInstanceTypes", + "Terraform": "master_instance_types", + "Required": true + }, + { + "ROS": null, + "Terraform": "master_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "master_period_unit", + "Required": false + }, + { + "ROS": "MasterSystemDiskCategory", + "Terraform": null, + "Required": false + }, + { + "ROS": "MasterSystemDiskPerformanceLevel", + "Terraform": null, + "Required": false + }, + { + "ROS": "MasterSystemDiskSize", + "Terraform": null, + "Required": false + }, + { + "ROS": "MasterSystemDiskSnapshotPolicyId", + "Terraform": null, + "Required": false + }, + { + "ROS": "MasterVSwitchIds", + "Terraform": "master_vswitch_ids", + "Required": true + }, + { + "ROS": "MasterZoneIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "Name", + "Terraform": "name", + "Required": true + }, + { + "ROS": null, + "Terraform": "new_nat_gateway", + "Required": false + }, + { + "ROS": "NodeCidrMask", + "Terraform": "node_cidr_mask", + "Required": false + }, + { + "ROS": "NodeNameMode", + "Terraform": "node_name_mode", + "Required": false + }, + { + "ROS": "NodePools", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "KubernetesConfig", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "CpuPolicy", + "Terraform": null, + "Required": false + }, + { + "ROS": "Labels", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "NodeNameMode", + "Terraform": null, + "Required": false + }, + { + "ROS": "Runtime", + "Terraform": null, + "Required": true + }, + { + "ROS": "RuntimeVersion", + "Terraform": null, + "Required": true + }, + { + "ROS": "Taints", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Effect", + "Terraform": null, + "Required": false + }, + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + } + ] + }, + { + "ROS": "NodePoolInfo", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "Type", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "ScalingGroup", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "DataDisks", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "AutoSnapshotPolicyId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::AutoSnapshotPolicy" + } + ] + }, + { + "ROS": "Category", + "Terraform": null, + "Required": false + }, + { + "ROS": "Encrypted", + "Terraform": null, + "Required": false + }, + { + "ROS": "PerformanceLevel", + "Terraform": null, + "Required": false + }, + { + "ROS": "Size", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "DesiredSize", + "Terraform": null, + "Required": false + }, + { + "ROS": "ImageId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::CustomImage" + } + ] + }, + { + "ROS": "InstanceChargeType", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceTypes", + "Terraform": null, + "Required": true, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "InternetChargeType", + "Terraform": null, + "Required": false + }, + { + "ROS": "InternetMaxBandwidthOut", + "Terraform": null, + "Required": false + }, + { + "ROS": "IsEnterpriseSecurityGroup", + "Terraform": null, + "Required": false + }, + { + "ROS": "KeyPair", + "Terraform": null, + "Required": false + }, + { + "ROS": "LoginPassword", + "Terraform": null, + "Required": false + }, + { + "ROS": "Period", + "Terraform": null, + "Required": false + }, + { + "ROS": "PeriodUnit", + "Terraform": null, + "Required": false + }, + { + "ROS": "RdsInstances", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "SystemDiskCategory", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskPerformanceLevel", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskSize", + "Terraform": null, + "Required": true + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "VSwitchIds", + "Terraform": null, + "Required": true, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "ZoneIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + } + ] + } + ], + "Type": "list" + }, + { + "ROS": "NodePortRange", + "Terraform": "node_port_range", + "Required": false + }, + { + "ROS": null, + "Terraform": "nodes", + "Required": false + }, + { + "ROS": "OsType", + "Terraform": "os_type", + "Required": false + }, + { + "ROS": "LoginPassword", + "Terraform": "password", + "Required": false + }, + { + "ROS": "Platform", + "Terraform": "platform", + "Required": false + }, + { + "ROS": null, + "Terraform": "pod_cidr", + "Required": false + }, + { + "ROS": "PodVswitchIds", + "Terraform": "pod_vswitch_ids", + "Required": false + }, + { + "ROS": "ProxyMode", + "Terraform": "proxy_mode", + "Required": false + }, + { + "ROS": null, + "Terraform": "rds_instances", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "retain_resources", + "Required": false + }, + { + "ROS": "Runtime", + "Terraform": "runtime", + "Required": false + }, + { + "ROS": "SecurityGroupId", + "Terraform": "security_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "SecurityHardeningOs", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "service_account_issuer", + "Required": false + }, + { + "ROS": "ServiceCidr", + "Terraform": "service_cidr", + "Required": false + }, + { + "ROS": null, + "Terraform": "slb_internet_enabled", + "Required": false + }, + { + "ROS": "SnatEntry", + "Terraform": null, + "Required": false + }, + { + "ROS": "SocEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "Taint", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": null, + "Terraform": "taints", + "Required": false + }, + { + "ROS": "TimeoutMins", + "Terraform": null, + "Required": false + }, + { + "ROS": "TimeZone", + "Terraform": "timezone", + "Required": false + }, + { + "ROS": "UserCa", + "Terraform": "user_ca", + "Required": false + }, + { + "ROS": "UserData", + "Terraform": "user_data", + "Required": false + }, + { + "ROS": "KubernetesVersion", + "Terraform": "version", + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": null, + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": null, + "Terraform": "vswitch_ids", + "Required": false + }, + { + "ROS": null, + "Terraform": "worker_auto_renew", + "Required": false + }, + { + "ROS": null, + "Terraform": "worker_auto_renew_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "worker_data_disk_category", + "Required": false + }, + { + "ROS": "WorkerDataDisks", + "Terraform": "worker_data_disks", + "Required": false, + "Properties": [ + { + "ROS": null, + "Terraform": "auto_snapshot_policy_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::AutoSnapshotPolicy" + } + ] + }, + { + "ROS": "Category", + "Terraform": "category", + "Required": false + }, + { + "ROS": null, + "Terraform": "device", + "Required": false + }, + { + "ROS": null, + "Terraform": "encrypted", + "Required": false + }, + { + "ROS": null, + "Terraform": "kms_key_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "name", + "Required": false + }, + { + "ROS": null, + "Terraform": "performance_level", + "Required": false + }, + { + "ROS": "Size", + "Terraform": "size", + "Required": false + }, + { + "ROS": null, + "Terraform": "snapshot_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Snapshot" + } + ] + } + ], + "Type": "list" + }, + { + "ROS": null, + "Terraform": "worker_data_disk_size", + "Required": false + }, + { + "ROS": null, + "Terraform": "worker_disk_category", + "Required": false + }, + { + "ROS": null, + "Terraform": "worker_disk_performance_level", + "Required": false + }, + { + "ROS": null, + "Terraform": "worker_disk_size", + "Required": false + }, + { + "ROS": null, + "Terraform": "worker_disk_snapshot_policy_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "worker_instance_charge_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "worker_instance_type", + "Required": false + }, + { + "ROS": "WorkerInstanceTypes", + "Terraform": "worker_instance_types", + "Required": false + }, + { + "ROS": null, + "Terraform": "worker_number", + "Required": false + }, + { + "ROS": null, + "Terraform": "worker_numbers", + "Required": false + }, + { + "ROS": null, + "Terraform": "worker_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "worker_period_unit", + "Required": false + }, + { + "ROS": "WorkerSystemDiskSnapshotPolicyId", + "Terraform": null, + "Required": false + }, + { + "ROS": "WorkerVSwitchIds", + "Terraform": "worker_vswitch_ids", + "Required": false + }, + { + "ROS": "WorkerZoneIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "APIServerSLBId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "certificate_authority" + }, + { + "ROS": null, + "Terraform": "connections" + }, + { + "ROS": "DefaultUserKubeConfig", + "Terraform": null + }, + { + "ROS": "ClusterId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "IngressSLBId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "master_nodes" + }, + { + "ROS": null, + "Terraform": "nat_gateway_id" + }, + { + "ROS": "Nodes", + "Terraform": null + }, + { + "ROS": "PrivateUserKubConfig", + "Terraform": null + }, + { + "ROS": "ScalingConfigurationId", + "Terraform": null + }, + { + "ROS": "ScalingGroupId", + "Terraform": null + }, + { + "ROS": "ScalingRuleId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "slb_id" + }, + { + "ROS": null, + "Terraform": "slb_internet" + }, + { + "ROS": null, + "Terraform": "slb_intranet" + }, + { + "ROS": "TaskId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "vpc_id", + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": null, + "Terraform": "worker_nodes" + }, + { + "ROS": "WorkerRamRoleName", + "Terraform": "worker_ram_role_name" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CS::ManagedEdgeKubernetesCluster", + "Terraform": "alicloud_cs_edge_kubernetes" + }, + "ProductCode": "acs", + "Name": { + "zh": "Kubernetes边缘托管版集群", + "en": "ACK Edge Cluster" + }, + "Properties": [ + { + "ROS": "Addons", + "Terraform": "addons", + "Required": false, + "Properties": [ + { + "ROS": "Config", + "Terraform": "config", + "Required": false + }, + { + "ROS": "Disabled", + "Terraform": "disabled", + "Required": false + }, + { + "ROS": "Name", + "Terraform": "name", + "Required": true + }, + { + "ROS": null, + "Terraform": "version", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": null, + "Terraform": "availability_zone", + "Required": false + }, + { + "ROS": null, + "Terraform": "client_cert", + "Required": false + }, + { + "ROS": null, + "Terraform": "client_key", + "Required": false + }, + { + "ROS": "CloudMonitorFlags", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "cluster_ca_cert", + "Required": false + }, + { + "ROS": "ClusterSpec", + "Terraform": "cluster_spec", + "Required": false + }, + { + "ROS": "ContainerCidr", + "Terraform": null, + "Required": false + }, + { + "ROS": "DeletionProtection", + "Terraform": "deletion_protection", + "Required": false + }, + { + "ROS": "EndpointPublicAccess", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "force_update", + "Required": false + }, + { + "ROS": null, + "Terraform": "install_cloud_monitor", + "Required": false + }, + { + "ROS": "IsEnterpriseSecurityGroup", + "Terraform": "is_enterprise_security_group", + "Required": false + }, + { + "ROS": null, + "Terraform": "key_name", + "Required": false + }, + { + "ROS": "KeyPair", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "load_balancer_spec", + "Required": false + }, + { + "ROS": "LoginPassword", + "Terraform": null, + "Required": false + }, + { + "ROS": "MaintenanceWindow", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Duration", + "Terraform": null, + "Required": false + }, + { + "ROS": "Enable", + "Terraform": null, + "Required": false + }, + { + "ROS": "MaintenanceTime", + "Terraform": null, + "Required": false + }, + { + "ROS": "Recurrence", + "Terraform": null, + "Required": false + }, + { + "ROS": "WeeklyPeriod", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "Name", + "Terraform": "name", + "Required": true + }, + { + "ROS": null, + "Terraform": "name_prefix", + "Required": false + }, + { + "ROS": null, + "Terraform": "new_nat_gateway", + "Required": false + }, + { + "ROS": "NodeCidrMask", + "Terraform": "node_cidr_mask", + "Required": false + }, + { + "ROS": null, + "Terraform": "password", + "Required": false + }, + { + "ROS": null, + "Terraform": "pod_cidr", + "Required": false + }, + { + "ROS": "Profile", + "Terraform": null, + "Required": false + }, + { + "ROS": "ProxyMode", + "Terraform": "proxy_mode", + "Required": false + }, + { + "ROS": null, + "Terraform": "rds_instances", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "retain_resources", + "Required": false + }, + { + "ROS": null, + "Terraform": "runtime", + "Required": false + }, + { + "ROS": null, + "Terraform": "security_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "ServiceCidr", + "Terraform": "service_cidr", + "Required": false + }, + { + "ROS": null, + "Terraform": "slb_internet_enabled", + "Required": false + }, + { + "ROS": "SnatEntry", + "Terraform": null, + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "TimeoutMins", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "user_data", + "Required": false + }, + { + "ROS": null, + "Terraform": "version", + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "WorkerDataDisks", + "Terraform": "worker_data_disks", + "Required": false, + "Properties": [ + { + "ROS": null, + "Terraform": "auto_snapshot_policy_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::AutoSnapshotPolicy" + } + ] + }, + { + "ROS": "Category", + "Terraform": "category", + "Required": false + }, + { + "ROS": null, + "Terraform": "device", + "Required": false + }, + { + "ROS": null, + "Terraform": "encrypted", + "Required": false + }, + { + "ROS": null, + "Terraform": "kms_key_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "name", + "Required": false + }, + { + "ROS": null, + "Terraform": "performance_level", + "Required": false + }, + { + "ROS": "Size", + "Terraform": "size", + "Required": false + }, + { + "ROS": null, + "Terraform": "snapshot_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Snapshot" + } + ] + } + ], + "Type": "list" + }, + { + "ROS": null, + "Terraform": "worker_disk_category", + "Required": false + }, + { + "ROS": null, + "Terraform": "worker_disk_performance_level", + "Required": false + }, + { + "ROS": null, + "Terraform": "worker_disk_size", + "Required": false + }, + { + "ROS": null, + "Terraform": "worker_disk_snapshot_policy_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "worker_instance_charge_type", + "Required": false + }, + { + "ROS": "WorkerInstanceTypes", + "Terraform": "worker_instance_types", + "Required": false + }, + { + "ROS": null, + "Terraform": "worker_number", + "Required": false + }, + { + "ROS": "WorkerVSwitchIds", + "Terraform": "worker_vswitch_ids", + "Required": false + }, + { + "ROS": "ZoneIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "APIServerSLBId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "certificate_authority" + }, + { + "ROS": null, + "Terraform": "connections" + }, + { + "ROS": "DefaultUserKubeConfig", + "Terraform": null + }, + { + "ROS": "ClusterId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "IngressSLBId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "nat_gateway_id" + }, + { + "ROS": "Nodes", + "Terraform": null + }, + { + "ROS": "PrivateUserKubConfig", + "Terraform": null + }, + { + "ROS": "ScalingConfigurationId", + "Terraform": null + }, + { + "ROS": "ScalingGroupId", + "Terraform": null + }, + { + "ROS": "ScalingRuleId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "slb_internet" + }, + { + "ROS": null, + "Terraform": "slb_intranet" + }, + { + "ROS": "TaskId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "vpc_id", + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": null, + "Terraform": "worker_nodes" + }, + { + "ROS": "WorkerRamRoleName", + "Terraform": "worker_ram_role_name" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CS::ManagedKubernetesCluster", + "Terraform": "alicloud_cs_managed_kubernetes" + }, + "ProductCode": "acs", + "Name": { + "zh": "Kubernetes托管版集群", + "en": "ACK Managed Cluster" + }, + "Properties": [ + { + "ROS": "Addons", + "Terraform": "addons", + "Required": false, + "Properties": [ + { + "ROS": "Config", + "Terraform": "config", + "Required": false + }, + { + "ROS": "Disabled", + "Terraform": "disabled", + "Required": false + }, + { + "ROS": "Name", + "Terraform": "name", + "Required": true + }, + { + "ROS": "Version", + "Terraform": "version", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": null, + "Terraform": "api_audiences", + "Required": false + }, + { + "ROS": null, + "Terraform": "availability_zone", + "Required": false + }, + { + "ROS": null, + "Terraform": "client_cert", + "Required": false + }, + { + "ROS": null, + "Terraform": "client_key", + "Required": false + }, + { + "ROS": null, + "Terraform": "cluster_ca_cert", + "Required": false + }, + { + "ROS": null, + "Terraform": "cluster_domain", + "Required": false + }, + { + "ROS": null, + "Terraform": "cluster_network_type", + "Required": false + }, + { + "ROS": "ClusterSpec", + "Terraform": "cluster_spec", + "Required": false + }, + { + "ROS": "ContainerCidr", + "Terraform": null, + "Required": false + }, + { + "ROS": "ControlPlaneLogComponents", + "Terraform": "control_plane_log_components", + "Required": false + }, + { + "ROS": "ControlPlaneLogProject", + "Terraform": "control_plane_log_project", + "Required": false + }, + { + "ROS": "ControlPlaneLogTtl", + "Terraform": "control_plane_log_ttl", + "Required": false + }, + { + "ROS": "CpuPolicy", + "Terraform": "cpu_policy", + "Required": false + }, + { + "ROS": null, + "Terraform": "custom_san", + "Required": false + }, + { + "ROS": "DeleteOptions", + "Terraform": "delete_options", + "Required": false, + "Properties": [ + { + "ROS": "DeleteMode", + "Terraform": "delete_mode", + "Required": false + }, + { + "ROS": "ResourceType", + "Terraform": "resource_type", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "DeletionProtection", + "Terraform": "deletion_protection", + "Required": false + }, + { + "ROS": null, + "Terraform": "enable_rrsa", + "Required": false + }, + { + "ROS": "SshFlags", + "Terraform": "enable_ssh", + "Required": false + }, + { + "ROS": "EncryptionProviderKey", + "Terraform": "encryption_provider_key", + "Required": false + }, + { + "ROS": "EndpointPublicAccess", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "exclude_autoscaler_nodes", + "Required": false + }, + { + "ROS": null, + "Terraform": "force_update", + "Required": false + }, + { + "ROS": "FormatDisk", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "image_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::CustomImage" + } + ] + }, + { + "ROS": "CloudMonitorFlags", + "Terraform": "install_cloud_monitor", + "Required": false + }, + { + "ROS": "IsEnterpriseSecurityGroup", + "Terraform": "is_enterprise_security_group", + "Required": false + }, + { + "ROS": "KeepInstanceName", + "Terraform": null, + "Required": false + }, + { + "ROS": "KeyPair", + "Terraform": "key_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "kms_encrypted_password", + "Required": false + }, + { + "ROS": null, + "Terraform": "kms_encryption_context", + "Required": false + }, + { + "ROS": null, + "Terraform": "kube_config", + "Required": false + }, + { + "ROS": "LoadBalancerSpec", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "log_config", + "Required": false + }, + { + "ROS": "MaintenanceWindow", + "Terraform": "maintenance_window", + "Required": false + }, + { + "ROS": "Name", + "Terraform": "name", + "Required": true + }, + { + "ROS": null, + "Terraform": "name_prefix", + "Required": false + }, + { + "ROS": null, + "Terraform": "new_nat_gateway", + "Required": false + }, + { + "ROS": "NodeCidrMask", + "Terraform": "node_cidr_mask", + "Required": false + }, + { + "ROS": "NodeNameMode", + "Terraform": "node_name_mode", + "Required": false + }, + { + "ROS": "NodePools", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "KubernetesConfig", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "CpuPolicy", + "Terraform": null, + "Required": false + }, + { + "ROS": "Labels", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "NodeNameMode", + "Terraform": null, + "Required": false + }, + { + "ROS": "Runtime", + "Terraform": null, + "Required": true + }, + { + "ROS": "RuntimeVersion", + "Terraform": null, + "Required": true + }, + { + "ROS": "Taints", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Effect", + "Terraform": null, + "Required": false + }, + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + } + ] + }, + { + "ROS": "NodePoolInfo", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "Type", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "ScalingGroup", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "DataDisks", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "AutoSnapshotPolicyId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::AutoSnapshotPolicy" + } + ] + }, + { + "ROS": "Category", + "Terraform": null, + "Required": false + }, + { + "ROS": "Encrypted", + "Terraform": null, + "Required": false + }, + { + "ROS": "PerformanceLevel", + "Terraform": null, + "Required": false + }, + { + "ROS": "Size", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "DesiredSize", + "Terraform": null, + "Required": false + }, + { + "ROS": "ImageId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::CustomImage" + } + ] + }, + { + "ROS": "InstanceChargeType", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceTypes", + "Terraform": null, + "Required": true, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "InternetChargeType", + "Terraform": null, + "Required": false + }, + { + "ROS": "InternetMaxBandwidthOut", + "Terraform": null, + "Required": false + }, + { + "ROS": "IsEnterpriseSecurityGroup", + "Terraform": null, + "Required": false + }, + { + "ROS": "KeyPair", + "Terraform": null, + "Required": false + }, + { + "ROS": "LoginPassword", + "Terraform": null, + "Required": false + }, + { + "ROS": "Period", + "Terraform": null, + "Required": false + }, + { + "ROS": "PeriodUnit", + "Terraform": null, + "Required": false + }, + { + "ROS": "RdsInstances", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "SystemDiskCategory", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskPerformanceLevel", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskSize", + "Terraform": null, + "Required": true + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "VSwitchIds", + "Terraform": null, + "Required": true, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "ZoneIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + } + ] + } + ], + "Type": "list" + }, + { + "ROS": null, + "Terraform": "node_port_range", + "Required": false + }, + { + "ROS": null, + "Terraform": "operation_policy", + "Required": false + }, + { + "ROS": "OsType", + "Terraform": "os_type", + "Required": false + }, + { + "ROS": "LoginPassword", + "Terraform": "password", + "Required": false + }, + { + "ROS": "Platform", + "Terraform": "platform", + "Required": false + }, + { + "ROS": null, + "Terraform": "pod_cidr", + "Required": false + }, + { + "ROS": "PodVswitchIds", + "Terraform": "pod_vswitch_ids", + "Required": false + }, + { + "ROS": "ProxyMode", + "Terraform": "proxy_mode", + "Required": false + }, + { + "ROS": null, + "Terraform": "rds_instances", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "retain_resources", + "Required": false + }, + { + "ROS": "Runtime", + "Terraform": "runtime", + "Required": false + }, + { + "ROS": "SecurityGroupId", + "Terraform": "security_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "SecurityHardeningOs", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "service_account_issuer", + "Required": false + }, + { + "ROS": "ServiceCidr", + "Terraform": "service_cidr", + "Required": false + }, + { + "ROS": null, + "Terraform": "slb_internet_enabled", + "Required": false + }, + { + "ROS": "SnatEntry", + "Terraform": null, + "Required": false + }, + { + "ROS": "SocEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "Taint", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": null, + "Terraform": "taints", + "Required": false + }, + { + "ROS": "TimeoutMins", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "timezone", + "Required": false + }, + { + "ROS": null, + "Terraform": "user_ca", + "Required": false + }, + { + "ROS": "UserData", + "Terraform": "user_data", + "Required": false + }, + { + "ROS": "KubernetesVersion", + "Terraform": "version", + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": null, + "Terraform": "vswitch_ids", + "Required": false + }, + { + "ROS": null, + "Terraform": "worker_auto_renew", + "Required": false + }, + { + "ROS": null, + "Terraform": "worker_auto_renew_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "worker_data_disk_category", + "Required": false + }, + { + "ROS": "WorkerDataDisks", + "Terraform": "worker_data_disks", + "Required": false, + "Properties": [ + { + "ROS": null, + "Terraform": "auto_snapshot_policy_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::AutoSnapshotPolicy" + } + ] + }, + { + "ROS": "Category", + "Terraform": "category", + "Required": false + }, + { + "ROS": null, + "Terraform": "device", + "Required": false + }, + { + "ROS": null, + "Terraform": "encrypted", + "Required": false + }, + { + "ROS": null, + "Terraform": "kms_key_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "name", + "Required": false + }, + { + "ROS": "PerformanceLevel", + "Terraform": "performance_level", + "Required": false + }, + { + "ROS": "Size", + "Terraform": "size", + "Required": false + }, + { + "ROS": null, + "Terraform": "snapshot_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Snapshot" + } + ] + } + ], + "Type": "list" + }, + { + "ROS": null, + "Terraform": "worker_data_disk_size", + "Required": false + }, + { + "ROS": null, + "Terraform": "worker_disk_category", + "Required": false + }, + { + "ROS": null, + "Terraform": "worker_disk_performance_level", + "Required": false + }, + { + "ROS": null, + "Terraform": "worker_disk_size", + "Required": false + }, + { + "ROS": null, + "Terraform": "worker_disk_snapshot_policy_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "worker_instance_charge_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "worker_instance_type", + "Required": false + }, + { + "ROS": "WorkerInstanceTypes", + "Terraform": "worker_instance_types", + "Required": false + }, + { + "ROS": null, + "Terraform": "worker_number", + "Required": false + }, + { + "ROS": null, + "Terraform": "worker_numbers", + "Required": false + }, + { + "ROS": null, + "Terraform": "worker_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "worker_period_unit", + "Required": false + }, + { + "ROS": "WorkerVSwitchIds", + "Terraform": "worker_vswitch_ids", + "Required": false + }, + { + "ROS": "ZoneIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "APIServerSLBId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "certificate_authority" + }, + { + "ROS": null, + "Terraform": "connections" + }, + { + "ROS": "DefaultUserKubeConfig", + "Terraform": null + }, + { + "ROS": "ClusterId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "IngressSLBId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "nat_gateway_id" + }, + { + "ROS": "Nodes", + "Terraform": null + }, + { + "ROS": "PrivateUserKubConfig", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "rrsa_metadata" + }, + { + "ROS": "ScalingConfigurationId", + "Terraform": null + }, + { + "ROS": "ScalingGroupId", + "Terraform": null + }, + { + "ROS": "ScalingRuleId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "slb_id" + }, + { + "ROS": null, + "Terraform": "slb_internet" + }, + { + "ROS": null, + "Terraform": "slb_intranet" + }, + { + "ROS": "TaskId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "vpc_id", + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": null, + "Terraform": "worker_nodes" + }, + { + "ROS": "WorkerRamRoleName", + "Terraform": "worker_ram_role_name" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CS::ServerlessKubernetesCluster", + "Terraform": "alicloud_cs_serverless_kubernetes" + }, + "ProductCode": "acs", + "Name": { + "zh": "Serverless Kubernetes集群", + "en": "ASK Cluster" + }, + "Properties": [ + { + "ROS": "Addons", + "Terraform": "addons", + "Required": false, + "Properties": [ + { + "ROS": "Config", + "Terraform": "config", + "Required": false + }, + { + "ROS": "Disabled", + "Terraform": "disabled", + "Required": false + }, + { + "ROS": "Name", + "Terraform": "name", + "Required": true + }, + { + "ROS": null, + "Terraform": "version", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": null, + "Terraform": "client_cert", + "Required": false + }, + { + "ROS": null, + "Terraform": "client_key", + "Required": false + }, + { + "ROS": null, + "Terraform": "cluster_ca_cert", + "Required": false + }, + { + "ROS": null, + "Terraform": "cluster_spec", + "Required": false + }, + { + "ROS": null, + "Terraform": "create_v2_cluster", + "Required": false + }, + { + "ROS": null, + "Terraform": "custom_san", + "Required": false + }, + { + "ROS": null, + "Terraform": "delete_options", + "Required": false + }, + { + "ROS": null, + "Terraform": "deletion_protection", + "Required": false + }, + { + "ROS": null, + "Terraform": "enable_rrsa", + "Required": false + }, + { + "ROS": "EndpointPublicAccess", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "endpoint_public_access_enabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "force_update", + "Required": false + }, + { + "ROS": "KubernetesVersion", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "maintenance_window", + "Required": false + }, + { + "ROS": "Name", + "Terraform": "name", + "Required": true + }, + { + "ROS": null, + "Terraform": "name_prefix", + "Required": false + }, + { + "ROS": "NatGateway", + "Terraform": "new_nat_gateway", + "Required": false + }, + { + "ROS": null, + "Terraform": "operation_policy", + "Required": false + }, + { + "ROS": "PrivateZone", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "retain_resources", + "Required": false + }, + { + "ROS": "SecurityGroupId", + "Terraform": "security_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "ServiceCidr", + "Terraform": "service_cidr", + "Required": false + }, + { + "ROS": null, + "Terraform": "service_discovery_types", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": null, + "Terraform": "time_zone", + "Required": false + }, + { + "ROS": null, + "Terraform": "version", + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_ids", + "Required": false + }, + { + "ROS": "ZoneId", + "Terraform": "zone_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "APIServerSLBId", + "Terraform": null + }, + { + "ROS": "DefaultUserKubeConfig", + "Terraform": null + }, + { + "ROS": "ClusterId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "IngressSLBId", + "Terraform": null + }, + { + "ROS": "Nodes", + "Terraform": null + }, + { + "ROS": "PrivateUserKubConfig", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "rrsa_metadata" + }, + { + "ROS": "ScalingConfigurationId", + "Terraform": null + }, + { + "ROS": "ScalingGroupId", + "Terraform": null + }, + { + "ROS": "ScalingRuleId", + "Terraform": null + }, + { + "ROS": "TaskId", + "Terraform": null + }, + { + "ROS": "WorkerRamRoleName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ClickHouse::DBCluster", + "Terraform": "alicloud_click_house_db_cluster" + }, + "ProductCode": "clickhouse", + "Name": { + "zh": "ClickHouse DBCluster", + "en": "ApsaraDB for ClickHouse Cluster" + }, + "Properties": [ + { + "ROS": "Category", + "Terraform": "category", + "Required": true + }, + { + "ROS": null, + "Terraform": "db_cluster_access_white_list", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_cluster_class", + "Required": false + }, + { + "ROS": "DBClusterDescription", + "Terraform": "db_cluster_description", + "Required": false + }, + { + "ROS": "DBClusterNetworkType", + "Terraform": "db_cluster_network_type", + "Required": false + }, + { + "ROS": "DBClusterType", + "Terraform": null, + "Required": true + }, + { + "ROS": "DBClusterVersion", + "Terraform": "db_cluster_version", + "Required": false + }, + { + "ROS": "DBNodeCount", + "Terraform": null, + "Required": true + }, + { + "ROS": null, + "Terraform": "db_node_group_count", + "Required": false + }, + { + "ROS": "DBNodeStorage", + "Terraform": "db_node_storage", + "Required": false + }, + { + "ROS": "DbNodeStorageType", + "Terraform": null, + "Required": true + }, + { + "ROS": "EncryptionKey", + "Terraform": "encryption_key", + "Required": false + }, + { + "ROS": "EncryptionType", + "Terraform": "encryption_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "maintain_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "multi_zone_vswitch_list", + "Required": false + }, + { + "ROS": "PaymentType", + "Terraform": "payment_type", + "Required": true + }, + { + "ROS": "Period", + "Terraform": "period", + "Required": false + }, + { + "ROS": null, + "Terraform": "renewal_status", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": null, + "Terraform": "storage_type", + "Required": false + }, + { + "ROS": "UsedTime", + "Terraform": "used_time", + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "ZoneId", + "Terraform": "zone_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "AliUid", + "Terraform": null + }, + { + "ROS": "Bid", + "Terraform": null + }, + { + "ROS": "Category", + "Terraform": null + }, + { + "ROS": "CommodityCode", + "Terraform": null + }, + { + "ROS": "ConnectionString", + "Terraform": "connection_string" + }, + { + "ROS": "DBClusterDescription", + "Terraform": null + }, + { + "ROS": "DBClusterNetworkType", + "Terraform": null + }, + { + "ROS": "DBClusterType", + "Terraform": null + }, + { + "ROS": "DBClusterVersion", + "Terraform": null + }, + { + "ROS": "DBNodeClass", + "Terraform": null + }, + { + "ROS": "DBNodeCount", + "Terraform": null + }, + { + "ROS": "DBNodeStorage", + "Terraform": null + }, + { + "ROS": "DbNodeStorageType", + "Terraform": null + }, + { + "ROS": "EncryptionKey", + "Terraform": null + }, + { + "ROS": "EncryptionType", + "Terraform": null + }, + { + "ROS": "Engine", + "Terraform": null + }, + { + "ROS": "EngineVersion", + "Terraform": null + }, + { + "ROS": "DBClusterId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "IsExpired", + "Terraform": null + }, + { + "ROS": "LockMode", + "Terraform": null + }, + { + "ROS": "LockReason", + "Terraform": null + }, + { + "ROS": "PaymentType", + "Terraform": null + }, + { + "ROS": "Period", + "Terraform": null + }, + { + "ROS": "Port", + "Terraform": "port" + }, + { + "ROS": "PublicConnectionString", + "Terraform": null + }, + { + "ROS": "PublicPort", + "Terraform": null + }, + { + "ROS": "StorageType", + "Terraform": null + }, + { + "ROS": "VpcCloudInstanceId", + "Terraform": null + }, + { + "ROS": "VpcId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "ZoneId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ClickHouse::SynDb", + "Terraform": null + }, + "ProductCode": "clickhouse", + "Name": { + "zh": "ClickHouse SynDb", + "en": "ApsaraDB for ClickHouse Cluster Synchronization Task" + }, + "Properties": [ + { + "ROS": "CkPassword", + "Terraform": null, + "Required": true + }, + { + "ROS": "CkUserName", + "Terraform": null, + "Required": true + }, + { + "ROS": "ClickhousePort", + "Terraform": null, + "Required": false + }, + { + "ROS": "DbClusterId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ClickHouse::DBCluster" + } + ] + }, + { + "ROS": "LimitUpper", + "Terraform": null, + "Required": false + }, + { + "ROS": "RdsId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::RDS::DBInstance" + } + ] + }, + { + "ROS": "RdsPassword", + "Terraform": null, + "Required": true + }, + { + "ROS": "RdsPort", + "Terraform": null, + "Required": false + }, + { + "ROS": "RdsUserName", + "Terraform": null, + "Required": true + }, + { + "ROS": "RdsVpcId", + "Terraform": null, + "Required": false + }, + { + "ROS": "RdsVpcUrl", + "Terraform": null, + "Required": false + }, + { + "ROS": "SkipUnsupported", + "Terraform": null, + "Required": true + }, + { + "ROS": "SynDbTables", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "Schema", + "Terraform": null, + "Required": true + }, + { + "ROS": "Tables", + "Terraform": null, + "Required": true, + "Properties": {}, + "Type": "list" + } + ], + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "DbClusterId", + "Terraform": null + }, + { + "ROS": "RdsId", + "Terraform": null + }, + { + "ROS": "SynDbs", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CloudPhone::Image", + "Terraform": null + }, + "ProductCode": "cloudphone", + "Name": { + "zh": "CloudPhone Image", + "en": "Cloud Phone Image" + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "ImageName", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CloudPhone::InstanceGroup" + } + ] + } + ], + "Attributes": [ + { + "ROS": "CreateTime", + "Terraform": null + }, + { + "ROS": "Description", + "Terraform": null + }, + { + "ROS": "ImageCategory", + "Terraform": null + }, + { + "ROS": "ImageId", + "Terraform": null, + "Primary": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::CustomImage" + } + ] + }, + { + "ROS": "ImageName", + "Terraform": null + }, + { + "ROS": "IsSelfShared", + "Terraform": null + }, + { + "ROS": "OsName", + "Terraform": null + }, + { + "ROS": "OsNameEn", + "Terraform": null + }, + { + "ROS": "OsType", + "Terraform": null + }, + { + "ROS": "Platform", + "Terraform": null + }, + { + "ROS": "Progress", + "Terraform": null + }, + { + "ROS": "Usage", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CloudPhone::InstanceGroup", + "Terraform": "alicloud_ecp_instance" + }, + "ProductCode": "cloudphone", + "Name": { + "zh": "云手机实例组", + "en": "Cloud Phones" + }, + "Properties": [ + { + "ROS": "Amount", + "Terraform": null, + "Required": false + }, + { + "ROS": "AutoPay", + "Terraform": "auto_pay", + "Required": false + }, + { + "ROS": "AutoRenew", + "Terraform": "auto_renew", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "EipBandwidth", + "Terraform": "eip_bandwidth", + "Required": false + }, + { + "ROS": null, + "Terraform": "force", + "Required": false + }, + { + "ROS": "ImageId", + "Terraform": "image_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CloudPhone::Image" + } + ] + }, + { + "ROS": "InstanceName", + "Terraform": "instance_name", + "Required": false + }, + { + "ROS": "InstanceType", + "Terraform": "instance_type", + "Required": true + }, + { + "ROS": "KeyPairName", + "Terraform": "key_pair_name", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CloudPhone::KeyPair" + } + ] + }, + { + "ROS": "ChargeType", + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": "Period", + "Terraform": "period", + "Required": false + }, + { + "ROS": "PeriodUnit", + "Terraform": "period_unit", + "Required": false + }, + { + "ROS": "Resolution", + "Terraform": "resolution", + "Required": false + }, + { + "ROS": "SecurityGroupId", + "Terraform": "security_group_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": "Tag", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "VncPassword", + "Terraform": "vnc_password", + "Required": false + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Attributes": [ + { + "ROS": "InstanceIds.0", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "OrderId", + "Terraform": null + }, + { + "ROS": "PrivateIps", + "Terraform": null + }, + { + "ROS": "TradePrice", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CloudPhone::KeyPair", + "Terraform": "alicloud_ecp_key_pair" + }, + "ProductCode": "cloudphone", + "Name": { + "zh": "CloudPhone KeyPair", + "en": "Cloud Phone Key Pair" + }, + "Properties": [ + { + "ROS": "KeyPairName", + "Terraform": "key_pair_name", + "Required": true + }, + { + "ROS": "PublicKeyBody", + "Terraform": "public_key_body", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "CreateTime", + "Terraform": null + }, + { + "ROS": "KeyPairName", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "KeyPairFingerPrint", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CloudPhone::RunCommand", + "Terraform": null + }, + "ProductCode": "cloudphone", + "Name": { + "zh": "CloudPhone RunCommand", + "en": "Run Command on Cloud Phone" + }, + "Properties": [ + { + "ROS": "Command", + "Terraform": null, + "Required": true + }, + { + "ROS": "InstanceIds", + "Terraform": null, + "Required": true, + "Properties": {}, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CloudPhone::InstanceGroup" + } + ], + "Type": "list" + }, + { + "ROS": "RunAgainOn", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::CloudStorageGateway::StorageBundle", + "Terraform": "alicloud_cloud_storage_gateway_storage_bundle" + }, + "ProductCode": "hcs_sgw", + "Name": { + "zh": "CloudStorageGateway StorageBundle", + "en": "CSG Gateway Cluster" + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "StorageBundleName", + "Terraform": "storage_bundle_name", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "CreateTime", + "Terraform": null + }, + { + "ROS": "Description", + "Terraform": null + }, + { + "ROS": "StorageBundleId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "StorageBundleName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ComputeNest::IntranetConnectorEndpoint", + "Terraform": null + }, + "ProductCode": "computenest", + "Name": { + "zh": "ComputeNest IntranetConnectorEndpoint", + "en": "Compute Nest Endpoint" + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "EnablePrivateZone", + "Terraform": null, + "Required": false + }, + { + "ROS": "EndpointRegionId", + "Terraform": null, + "Required": true + }, + { + "ROS": "Name", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "Type", + "Terraform": null, + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ], + "Attributes": [ + { + "ROS": "EndpointId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ComputeNest::ServiceInstance", + "Terraform": "alicloud_compute_nest_service_instance" + }, + "ProductCode": "computenest", + "Name": { + "zh": "ComputeNest ServiceInstance", + "en": "Compute Nest Service Instance" + }, + "Properties": [ + { + "ROS": "Commodity", + "Terraform": "commodity", + "Required": false + }, + { + "ROS": "ContactGroup", + "Terraform": null, + "Required": false + }, + { + "ROS": "EnableInstanceOps", + "Terraform": "enable_instance_ops", + "Required": false + }, + { + "ROS": "EnableUserPrometheus", + "Terraform": "enable_user_prometheus", + "Required": false + }, + { + "ROS": "MarketInstanceId", + "Terraform": null, + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "operation_metadata", + "Required": false + }, + { + "ROS": "OperationName", + "Terraform": null, + "Required": false + }, + { + "ROS": "Parameters", + "Terraform": "parameters", + "Required": false + }, + { + "ROS": null, + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": "PredefinedParameterName", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "Service", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "ServiceId", + "Terraform": null, + "Required": true + }, + { + "ROS": "Version", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": null, + "Terraform": "service_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "service_instance_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "service_version", + "Required": false + }, + { + "ROS": "SpecificationCode", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "specification_name", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "TemplateName", + "Terraform": "template_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Components", + "Terraform": null + }, + { + "ROS": "CreateTime", + "Terraform": null + }, + { + "ROS": "EnableInstanceOps", + "Terraform": null + }, + { + "ROS": "EnableUserPrometheus", + "Terraform": null + }, + { + "ROS": "ServiceInstanceId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "IsOperated", + "Terraform": null + }, + { + "ROS": "LicenseEndTime", + "Terraform": null + }, + { + "ROS": "Name", + "Terraform": null + }, + { + "ROS": "NetworkConfig", + "Terraform": null + }, + { + "ROS": "Outputs", + "Terraform": null + }, + { + "ROS": "Parameters", + "Terraform": null + }, + { + "ROS": "PredefinedParameterName", + "Terraform": null + }, + { + "ROS": "Progress", + "Terraform": null + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "Service", + "Terraform": null + }, + { + "ROS": "ServiceType", + "Terraform": null + }, + { + "ROS": "Source", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "StatusDetail", + "Terraform": null + }, + { + "ROS": "SupplierUid", + "Terraform": null + }, + { + "ROS": "Tags", + "Terraform": null + }, + { + "ROS": "TemplateName", + "Terraform": null + }, + { + "ROS": "UpdateTime", + "Terraform": null + }, + { + "ROS": "UserId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::Config::AggregateCompliancePack", + "Terraform": "alicloud_config_aggregate_compliance_pack" + }, + "ProductCode": "config", + "Name": { + "zh": "Config AggregateCompliancePack", + "en": "Cloud Config Account Group Compliance Package" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "aggregate_compliance_pack_name", + "Required": false + }, + { + "ROS": "AggregatorId", + "Terraform": "aggregator_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::Config::Aggregator" + } + ] + }, + { + "ROS": "CompliancePackName", + "Terraform": null, + "Required": true + }, + { + "ROS": "CompliancePackTemplateId", + "Terraform": "compliance_pack_template_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "config_rule_ids", + "Required": false + }, + { + "ROS": "ConfigRules", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "ConfigRuleId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::Config::Rule" + } + ] + }, + { + "ROS": "ConfigRuleName", + "Terraform": null, + "Required": false + }, + { + "ROS": "ConfigRuleParameters", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "ParameterName", + "Terraform": null, + "Required": true + }, + { + "ROS": "ParameterValue", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "ManagedRuleIdentifier", + "Terraform": null, + "Required": false + }, + { + "ROS": "RiskLevel", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "DefaultEnable", + "Terraform": null, + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": true + }, + { + "ROS": "ExcludeRegionIdsScope", + "Terraform": null, + "Required": false + }, + { + "ROS": "ExcludeResourceGroupIdsScope", + "Terraform": null, + "Required": false + }, + { + "ROS": "ExcludeResourceIdsScope", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "RegionIdsScope", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "ResourceGroupIdsScope", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "ResourceIdsScope", + "Terraform": null, + "Required": false + }, + { + "ROS": "RiskLevel", + "Terraform": "risk_level", + "Required": true + }, + { + "ROS": "TagKeyScope", + "Terraform": null, + "Required": false + }, + { + "ROS": "TagValueScope", + "Terraform": null, + "Required": false + }, + { + "ROS": "TemplateContent", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "aggregator_compliance_pack_id" + }, + { + "ROS": "CompliancePackId", + "Terraform": null + }, + { + "ROS": "CompliancePackId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::Config::Aggregator", + "Terraform": "alicloud_config_aggregator" + }, + "ProductCode": "config", + "Name": { + "zh": "Config Aggregator", + "en": "Config Account Group" + }, + "Properties": [ + { + "ROS": "AggregatorAccounts", + "Terraform": "aggregator_accounts", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::Account" + } + ], + "Properties": [ + { + "ROS": "AccountId", + "Terraform": "account_id", + "Required": true + }, + { + "ROS": "AccountName", + "Terraform": "account_name", + "Required": true + }, + { + "ROS": "AccountType", + "Terraform": "account_type", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "AggregatorName", + "Terraform": "aggregator_name", + "Required": true + }, + { + "ROS": "AggregatorType", + "Terraform": "aggregator_type", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": true + }, + { + "ROS": "FolderId", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "AggregatorId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::Config::CompliancePack", + "Terraform": "alicloud_config_compliance_pack" + }, + "ProductCode": "config", + "Name": { + "zh": "Config CompliancePack", + "en": "Cloud Config Compliance Package" + }, + "Properties": [ + { + "ROS": "CompliancePackName", + "Terraform": "compliance_pack_name", + "Required": true + }, + { + "ROS": "CompliancePackTemplateId", + "Terraform": "compliance_pack_template_id", + "Required": false + }, + { + "ROS": "ConfigRuleIds", + "Terraform": "config_rule_ids", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::Config::Rule" + } + ], + "Properties": [ + { + "ROS": "ConfigRuleId", + "Terraform": "config_rule_id", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "ConfigRules", + "Terraform": null, + "Required": true + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "RiskLevel", + "Terraform": "risk_level", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "AccountId", + "Terraform": null + }, + { + "ROS": "CompliancePackName", + "Terraform": null + }, + { + "ROS": "CompliancePackTemplateId", + "Terraform": null + }, + { + "ROS": "Description", + "Terraform": null + }, + { + "ROS": "CompliancePackId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "RiskLevel", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::Config::DeliveryChannel", + "Terraform": null + }, + "ProductCode": "config", + "Name": { + "zh": "Config DeliveryChannel", + "en": "Cloud Config Delivery Channel" + }, + "Properties": [ + { + "ROS": "DeliveryChannelAssumeRoleArn", + "Terraform": null, + "Required": true + }, + { + "ROS": "DeliveryChannelCondition", + "Terraform": null, + "Required": false + }, + { + "ROS": "DeliveryChannelName", + "Terraform": null, + "Required": false + }, + { + "ROS": "DeliveryChannelTargetArn", + "Terraform": null, + "Required": true + }, + { + "ROS": "DeliveryChannelType", + "Terraform": null, + "Required": true + }, + { + "ROS": "Description", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "DeliveryChannelId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::Config::Rule", + "Terraform": "alicloud_config_rule" + }, + "ProductCode": "config", + "Name": { + "zh": "Config Rule", + "en": "Cloud Config Rule" + }, + "Properties": [ + { + "ROS": "ConfigRuleTriggerTypes", + "Terraform": "config_rule_trigger_types", + "Required": true + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "ExcludeResourceIdsScope", + "Terraform": "exclude_resource_ids_scope", + "Required": false + }, + { + "ROS": "InputParameters", + "Terraform": "input_parameters", + "Required": false + }, + { + "ROS": "MaximumExecutionFrequency", + "Terraform": "maximum_execution_frequency", + "Required": false + }, + { + "ROS": "RegionIdsScope", + "Terraform": "region_ids_scope", + "Required": false + }, + { + "ROS": "ResourceGroupIdsScope", + "Terraform": "resource_group_ids_scope", + "Required": false + }, + { + "ROS": "ResourceTypesScope", + "Terraform": "resource_types_scope", + "Required": true + }, + { + "ROS": "RiskLevel", + "Terraform": "risk_level", + "Required": true + }, + { + "ROS": "RuleName", + "Terraform": "rule_name", + "Required": true + }, + { + "ROS": "SourceIdentifier", + "Terraform": "source_identifier", + "Required": true + }, + { + "ROS": "SourceOwner", + "Terraform": "source_owner", + "Required": true + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": "TagKeyLogicScope", + "Terraform": null, + "Required": false + }, + { + "ROS": "TagKeyScope", + "Terraform": "tag_key_scope", + "Required": false + }, + { + "ROS": "TagValueScope", + "Terraform": "tag_value_scope", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "account_id" + }, + { + "ROS": null, + "Terraform": "compliance" + }, + { + "ROS": null, + "Terraform": "compliance_pack_id" + }, + { + "ROS": "ConfigRuleArn", + "Terraform": "config_rule_arn" + }, + { + "ROS": "ConfigRuleId", + "Terraform": "config_rule_id" + }, + { + "ROS": "ConfigRuleTriggerTypes", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "Description", + "Terraform": null + }, + { + "ROS": "EventSource", + "Terraform": "event_source" + }, + { + "ROS": "ExcludeResourceIdsScope", + "Terraform": null + }, + { + "ROS": "ConfigRuleId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "InputParameters", + "Terraform": null + }, + { + "ROS": "MaximumExecutionFrequency", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "modified_timestamp" + }, + { + "ROS": "RegionIdsScope", + "Terraform": null + }, + { + "ROS": "ResourceGroupIdsScope", + "Terraform": null + }, + { + "ROS": "ResourceTypesScope", + "Terraform": null + }, + { + "ROS": "RiskLevel", + "Terraform": null + }, + { + "ROS": "RuleName", + "Terraform": null + }, + { + "ROS": "SourceIdentifier", + "Terraform": null + }, + { + "ROS": "SourceOwner", + "Terraform": null + }, + { + "ROS": "TagKeyScope", + "Terraform": null + }, + { + "ROS": "TagValueScope", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DATAHUB::Project", + "Terraform": "alicloud_datahub_project" + }, + "ProductCode": "datahub", + "Name": { + "zh": "DATAHUB Project", + "en": "DataHub Project" + }, + "Properties": [ + { + "ROS": "Comment", + "Terraform": "comment", + "Required": true + }, + { + "ROS": "ProjectName", + "Terraform": "name", + "Required": true + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "ProjectName", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "last_modify_time" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DATAHUB::Topic", + "Terraform": "alicloud_datahub_topic" + }, + "ProductCode": "datahub", + "Name": { + "zh": "DATAHUB Topic", + "en": "DataHub Topic" + }, + "Properties": [ + { + "ROS": "Comment", + "Terraform": "comment", + "Required": true + }, + { + "ROS": "Lifecycle", + "Terraform": "life_cycle", + "Required": false + }, + { + "ROS": "TopicName", + "Terraform": "name", + "Required": true + }, + { + "ROS": "ProjectName", + "Terraform": "project_name", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::DATAHUB::Project" + } + ] + }, + { + "ROS": "RecordSchema", + "Terraform": "record_schema", + "Required": false + }, + { + "ROS": "RecordType", + "Terraform": "record_type", + "Required": true + }, + { + "ROS": "ShardCount", + "Terraform": "shard_count", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "TopicName", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "last_modify_time" + }, + { + "ROS": "ProjectName", + "Terraform": null + }, + { + "ROS": "TopicName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DBS::Download", + "Terraform": null + }, + "ProductCode": "cbs", + "Name": { + "zh": "DBS Download", + "en": "DBS Download" + }, + "Properties": [ + { + "ROS": "BakSetId", + "Terraform": null, + "Required": false + }, + { + "ROS": "BakSetSize", + "Terraform": null, + "Required": false + }, + { + "ROS": "BakSetType", + "Terraform": null, + "Required": false + }, + { + "ROS": "DeleteBackupSetInOss", + "Terraform": null, + "Required": false + }, + { + "ROS": "DownloadAddressDuration", + "Terraform": null, + "Required": false + }, + { + "ROS": "DownloadPointInTime", + "Terraform": null, + "Required": false + }, + { + "ROS": "FormatType", + "Terraform": null, + "Required": true + }, + { + "ROS": "InstanceName", + "Terraform": null, + "Required": true + }, + { + "ROS": "TargetBucket", + "Terraform": null, + "Required": false + }, + { + "ROS": "TargetOssRegion", + "Terraform": null, + "Required": false + }, + { + "ROS": "TargetPath", + "Terraform": null, + "Required": false + }, + { + "ROS": "TargetType", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "BakSetId", + "Terraform": null + }, + { + "ROS": "DownloadAddressInfo", + "Terraform": null + }, + { + "ROS": "InstanceName", + "Terraform": null + }, + { + "ROS": "TaskId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DBS::RestoreTask", + "Terraform": null + }, + "ProductCode": "cbs", + "Name": { + "zh": "DBS RestoreTask", + "en": "DBS Restore Task" + }, + "Properties": [ + { + "ROS": "BackupGatewayId", + "Terraform": null, + "Required": false + }, + { + "ROS": "BackupPlanId", + "Terraform": null, + "Required": true + }, + { + "ROS": "BackupSetId", + "Terraform": null, + "Required": false + }, + { + "ROS": "DestinationEndpointDatabaseName", + "Terraform": null, + "Required": false + }, + { + "ROS": "DestinationEndpointInstanceID", + "Terraform": null, + "Required": false + }, + { + "ROS": "DestinationEndpointInstanceType", + "Terraform": null, + "Required": true + }, + { + "ROS": "DestinationEndpointIP", + "Terraform": null, + "Required": false + }, + { + "ROS": "DestinationEndpointOracleSID", + "Terraform": null, + "Required": false + }, + { + "ROS": "DestinationEndpointPassword", + "Terraform": null, + "Required": false + }, + { + "ROS": "DestinationEndpointPort", + "Terraform": null, + "Required": false + }, + { + "ROS": "DestinationEndpointRegion", + "Terraform": null, + "Required": false + }, + { + "ROS": "DestinationEndpointUserName", + "Terraform": null, + "Required": false + }, + { + "ROS": "DuplicateConflict", + "Terraform": null, + "Required": false + }, + { + "ROS": "RestoreDir", + "Terraform": null, + "Required": false + }, + { + "ROS": "RestoreHome", + "Terraform": null, + "Required": false + }, + { + "ROS": "RestoreObjects", + "Terraform": null, + "Required": false + }, + { + "ROS": "RestoreTaskName", + "Terraform": null, + "Required": true + }, + { + "ROS": "RestoreTime", + "Terraform": null, + "Required": false + }, + { + "ROS": "StartTask", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "RestoreTaskId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DCDN::Domain", + "Terraform": "alicloud_dcdn_domain" + }, + "ProductCode": "dcdn", + "Name": { + "zh": "DCDN Domain", + "en": "DCDN Domain" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "cert_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CAS::Certificate" + } + ] + }, + { + "ROS": null, + "Terraform": "cert_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "cert_region", + "Required": false + }, + { + "ROS": null, + "Terraform": "cert_type", + "Required": false + }, + { + "ROS": "CheckUrl", + "Terraform": "check_url", + "Required": false + }, + { + "ROS": "DomainName", + "Terraform": "domain_name", + "Required": true + }, + { + "ROS": null, + "Terraform": "env", + "Required": false + }, + { + "ROS": null, + "Terraform": "function_type", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "scene", + "Required": false + }, + { + "ROS": "Scope", + "Terraform": "scope", + "Required": false + }, + { + "ROS": "Sources", + "Terraform": "sources", + "Required": true, + "Properties": [ + { + "ROS": "Content", + "Terraform": "content", + "Required": true + }, + { + "ROS": "Port", + "Terraform": "port", + "Required": false + }, + { + "ROS": "Priority", + "Terraform": "priority", + "Required": false + }, + { + "ROS": "Type", + "Terraform": "type", + "Required": true + }, + { + "ROS": "Weight", + "Terraform": "weight", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": null, + "Terraform": "ssl_pri", + "Required": false + }, + { + "ROS": null, + "Terraform": "ssl_protocol", + "Required": false + }, + { + "ROS": null, + "Terraform": "ssl_pub", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "TopLevelDomain", + "Terraform": "top_level_domain", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": "Cname", + "Terraform": "cname" + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "DomainName", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DDoS::OriginInstance", + "Terraform": "alicloud_ddosbgp_instance" + }, + "ProductCode": "ddos", + "Name": { + "zh": "DDoS OriginInstance", + "en": "Anti-DDoS Origin Instance" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "bandwidth", + "Required": false + }, + { + "ROS": null, + "Terraform": "base_bandwidth", + "Required": false + }, + { + "ROS": "ChargeType", + "Terraform": null, + "Required": false + }, + { + "ROS": "CleanBandwidth", + "Terraform": null, + "Required": false + }, + { + "ROS": "Edition", + "Terraform": null, + "Required": true + }, + { + "ROS": "EnableLog", + "Terraform": null, + "Required": false + }, + { + "ROS": "IpAddresses", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "ip_count", + "Required": false + }, + { + "ROS": null, + "Terraform": "ip_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "name", + "Required": false + }, + { + "ROS": "NetworkProtocol", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "normal_bandwidth", + "Required": false + }, + { + "ROS": "Period", + "Terraform": "period", + "Required": false + }, + { + "ROS": "PeriodUnit", + "Terraform": null, + "Required": false + }, + { + "ROS": "ProtectionMode", + "Terraform": null, + "Required": true + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": null, + "Terraform": "type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": "InstanceId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DDoS::Policy", + "Terraform": "alicloud_ddos_bgp_policy" + }, + "ProductCode": "ddos", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "ActionType", + "Terraform": null, + "Required": false + }, + { + "ROS": "BlackIpList", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "Content", + "Terraform": "content", + "Required": false + }, + { + "ROS": "PolicyName", + "Terraform": "policy_name", + "Required": true + }, + { + "ROS": "Type", + "Terraform": "type", + "Required": true + }, + { + "ROS": "WhiteIpList", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "Content", + "Terraform": null + }, + { + "ROS": "PolicyId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "PolicyId", + "Terraform": null + }, + { + "ROS": "PolicyName", + "Terraform": null + }, + { + "ROS": "Type", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DDoSPro::Port", + "Terraform": "alicloud_ddoscoo_port" + }, + "ProductCode": "ddos", + "Name": { + "zh": "DDoSPro Port", + "en": "Anti-DDoS Proxy Port" + }, + "Properties": [ + { + "ROS": "BackendPort", + "Terraform": "backend_port", + "Required": false + }, + { + "ROS": null, + "Terraform": "config", + "Required": false + }, + { + "ROS": "FrontendPort", + "Terraform": "frontend_port", + "Required": false + }, + { + "ROS": "FrontendProtocol", + "Terraform": "frontend_protocol", + "Required": true + }, + { + "ROS": "InstanceId", + "Terraform": "instance_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::DDoS::OriginInstance" + }, + { + "ResourceType": "ROS/ALIYUN::DDoSPro::ProInstance" + }, + { + "ResourceType": "ROS/ALIYUN::DDoSPro::PremiumInstance" + } + ] + }, + { + "ROS": "RealServers", + "Terraform": "real_servers", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "FrontendPort", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DDoSPro::PremiumInstance", + "Terraform": null + }, + "ProductCode": "ddos", + "Name": { + "zh": "DDoSPro PremiumInstance", + "en": "Anti-DDoS Proxy (Outside Chinese Mainland) Instance" + }, + "Properties": [ + { + "ROS": "BurstBandwidthMode", + "Terraform": null, + "Required": false + }, + { + "ROS": "DomainCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "FunctionVersion", + "Terraform": null, + "Required": false + }, + { + "ROS": "NormalBandwidth", + "Terraform": null, + "Required": false + }, + { + "ROS": "NormalQps", + "Terraform": null, + "Required": false + }, + { + "ROS": "Period", + "Terraform": null, + "Required": false + }, + { + "ROS": "PeriodUnit", + "Terraform": null, + "Required": false + }, + { + "ROS": "PortCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "ProductPlan", + "Terraform": null, + "Required": false + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": "InstanceId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DDoSPro::ProInstance", + "Terraform": "alicloud_ddoscoo_instance" + }, + "ProductCode": "ddos", + "Name": { + "zh": "DDoSPro ProInstance", + "en": "Anti-DDoS Proxy (Chinese Mainland) Instance" + }, + "Properties": [ + { + "ROS": "AddressType", + "Terraform": "address_type", + "Required": false + }, + { + "ROS": "Bandwidth", + "Terraform": "bandwidth", + "Required": false + }, + { + "ROS": null, + "Terraform": "bandwidth_mode", + "Required": false + }, + { + "ROS": "BaseBandwidth", + "Terraform": "base_bandwidth", + "Required": false + }, + { + "ROS": "BurstBandwidthMode", + "Terraform": null, + "Required": false + }, + { + "ROS": "DomainCount", + "Terraform": "domain_count", + "Required": false + }, + { + "ROS": "Edition", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "edition_sale", + "Required": false + }, + { + "ROS": "FunctionVersion", + "Terraform": "function_version", + "Required": false + }, + { + "ROS": null, + "Terraform": "name", + "Required": false + }, + { + "ROS": null, + "Terraform": "normal_bandwidth", + "Required": false + }, + { + "ROS": "NormalQps", + "Terraform": "normal_qps", + "Required": false + }, + { + "ROS": "Period", + "Terraform": "period", + "Required": false + }, + { + "ROS": "PeriodUnit", + "Terraform": null, + "Required": false + }, + { + "ROS": "PortCount", + "Terraform": "port_count", + "Required": false + }, + { + "ROS": null, + "Terraform": "product_plan", + "Required": false + }, + { + "ROS": null, + "Terraform": "product_type", + "Required": false + }, + { + "ROS": "ServiceBandwidth", + "Terraform": "service_bandwidth", + "Required": false + }, + { + "ROS": "ServicePartner", + "Terraform": null, + "Required": false + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": "InstanceId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "ip" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DDoSPro::SceneDefensePolicy", + "Terraform": null + }, + "ProductCode": "ddos", + "Name": { + "zh": "DDoSPro SceneDefensePolicy", + "en": "Anti-DDoS Proxy Scenario-specific Custom Policy" + }, + "Properties": [ + { + "ROS": "EndTime", + "Terraform": null, + "Required": true + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "StartTime", + "Terraform": null, + "Required": true + }, + { + "ROS": "Template", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "Name", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DDoSPro::SchedulerRule", + "Terraform": "alicloud_ddoscoo_scheduler_rule" + }, + "ProductCode": "ddos", + "Name": { + "zh": "DDoSPro SchedulerRule", + "en": "Anti-DDoS Proxy Sec-Traffic Manager Scheduling Rule" + }, + "Properties": [ + { + "ROS": "Param", + "Terraform": "param", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "RuleName", + "Terraform": "rule_name", + "Required": true + }, + { + "ROS": "Rules", + "Terraform": "rules", + "Required": true + }, + { + "ROS": "RuleType", + "Terraform": "rule_type", + "Required": true + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "cname" + }, + { + "ROS": "RuleName", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DDoSPro::WebRule", + "Terraform": null + }, + "ProductCode": "ddos", + "Name": { + "zh": "DDoSPro WebRule", + "en": "Anti-DDoS Proxy Website Forwarding Rule" + }, + "Properties": [ + { + "ROS": "DefenseId", + "Terraform": null, + "Required": false + }, + { + "ROS": "Domain", + "Terraform": null, + "Required": true + }, + { + "ROS": "HttpsExt", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::DDoS::OriginInstance" + }, + { + "ResourceType": "ROS/ALIYUN::DDoSPro::ProInstance" + }, + { + "ResourceType": "ROS/ALIYUN::DDoSPro::PremiumInstance" + } + ], + "Type": "list" + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "RsType", + "Terraform": null, + "Required": true + }, + { + "ROS": "Rules", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "Domain", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DEVOPS::HostGroup", + "Terraform": null + }, + "ProductCode": "rdc", + "Name": { + "zh": "DEVOPS HostGroup", + "en": "Apsara DevOps Host Group" + }, + "Properties": [ + { + "ROS": "AliyunRegion", + "Terraform": null, + "Required": false + }, + { + "ROS": "EcsLabelKey", + "Terraform": null, + "Required": false + }, + { + "ROS": "EcsLabelValue", + "Terraform": null, + "Required": false + }, + { + "ROS": "EcsType", + "Terraform": null, + "Required": false + }, + { + "ROS": "EnvId", + "Terraform": null, + "Required": false + }, + { + "ROS": "MachineInfos", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "AliyunRegionId", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceName", + "Terraform": null, + "Required": false + }, + { + "ROS": "Ip", + "Terraform": null, + "Required": false + }, + { + "ROS": "MachineSn", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "OrganizationId", + "Terraform": null, + "Required": true + }, + { + "ROS": "ServiceConnectionId", + "Terraform": null, + "Required": true + }, + { + "ROS": "TagIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "Type", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "HostGroupId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DEVOPS::Pipeline", + "Terraform": null + }, + "ProductCode": "rdc", + "Name": { + "zh": "DEVOPS Pipeline", + "en": "Apsara DevOps Pipeline" + }, + "Properties": [ + { + "ROS": "Content", + "Terraform": null, + "Required": true + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "OrganizationId", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "PipelineId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DEVOPS::PipelineRelations", + "Terraform": null + }, + "ProductCode": "rdc", + "Name": { + "zh": "DEVOPS PipelineRelations", + "en": "Apsara DevOps Pipeline Relations" + }, + "Properties": [ + { + "ROS": "OrganizationId", + "Terraform": null, + "Required": true + }, + { + "ROS": "PipelineId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::DEVOPS::Pipeline" + } + ] + }, + { + "ROS": "RelObjectIds", + "Terraform": null, + "Required": true, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "RelObjectType", + "Terraform": null, + "Required": true + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DEVOPS::PipelineRun", + "Terraform": null + }, + "ProductCode": "rdc", + "Name": { + "zh": "DEVOPS PipelineRun", + "en": "Run Apsara DevOps Pipeline" + }, + "Properties": [ + { + "ROS": "OrganizationId", + "Terraform": null, + "Required": true + }, + { + "ROS": "Params", + "Terraform": null, + "Required": false + }, + { + "ROS": "PipelineId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::DEVOPS::Pipeline" + } + ] + }, + { + "ROS": "Sync", + "Terraform": null, + "Required": false + }, + { + "ROS": "Timeout", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "PipelineRunId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DEVOPS::VariableGroup", + "Terraform": null + }, + "ProductCode": "rdc", + "Name": { + "zh": "DEVOPS VariableGroup", + "en": "Apsara DevOps Variable Group" + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "OrganizationId", + "Terraform": null, + "Required": true + }, + { + "ROS": "Variables", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "isEncrypted", + "Terraform": null, + "Required": true + }, + { + "ROS": "name", + "Terraform": null, + "Required": true + }, + { + "ROS": "value", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "VariableGroupId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DFS::AccessGroup", + "Terraform": "alicloud_dfs_access_group" + }, + "ProductCode": "alidfs", + "Name": { + "zh": "DFS权限组", + "en": "Permission Group in Apsara File Storage for HDFS" + }, + "Properties": [ + { + "ROS": "AccessGroupName", + "Terraform": "access_group_name", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "NetworkType", + "Terraform": "network_type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "AccessGroupId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DFS::AccessRule", + "Terraform": "alicloud_dfs_access_rule" + }, + "ProductCode": "alidfs", + "Name": { + "zh": "DFS权限组规则", + "en": "Permission Group Rule in Apsara File Storage for HDFS" + }, + "Properties": [ + { + "ROS": "AccessGroupId", + "Terraform": "access_group_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::DFS::AccessGroup" + } + ] + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "NetworkSegment", + "Terraform": "network_segment", + "Required": true + }, + { + "ROS": "Priority", + "Terraform": "priority", + "Required": false + }, + { + "ROS": "RWAccessType", + "Terraform": "rw_access_type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "AccessRuleId", + "Terraform": "access_rule_id" + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "AccessRuleId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DFS::FileSystem", + "Terraform": "alicloud_dfs_file_system" + }, + "ProductCode": "alidfs", + "Name": { + "zh": "DFS文件系统", + "en": "File System of Apsara File Storage for HDFS" + }, + "Properties": [ + { + "ROS": "DataRedundancyType", + "Terraform": "data_redundancy_type", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "FileSystemName", + "Terraform": "file_system_name", + "Required": false + }, + { + "ROS": "PartitionNumber", + "Terraform": "partition_number", + "Required": false + }, + { + "ROS": "ProtocolType", + "Terraform": "protocol_type", + "Required": true + }, + { + "ROS": "ProvisionedThroughputInMiBps", + "Terraform": "provisioned_throughput_in_mi_bps", + "Required": false + }, + { + "ROS": "SpaceCapacity", + "Terraform": "space_capacity", + "Required": true + }, + { + "ROS": "StorageSetName", + "Terraform": "storage_set_name", + "Required": false + }, + { + "ROS": "StorageType", + "Terraform": "storage_type", + "Required": true + }, + { + "ROS": "ThroughputMode", + "Terraform": "throughput_mode", + "Required": false + }, + { + "ROS": "ZoneId", + "Terraform": "zone_id", + "Required": true + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "FileSystemId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DFS::MountPoint", + "Terraform": "alicloud_dfs_mount_point" + }, + "ProductCode": "alidfs", + "Name": { + "zh": "DFS挂载点", + "en": "Mount Target of Apsara File Storage for HDFS" + }, + "Properties": [ + { + "ROS": "AccessGroupId", + "Terraform": "access_group_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::DFS::AccessGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "alias_prefix", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "FileSystemId", + "Terraform": "file_system_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::DFS::FileSystem" + } + ] + }, + { + "ROS": "NetworkType", + "Terraform": "network_type", + "Required": true + }, + { + "ROS": "Status", + "Terraform": "status", + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "MountPointId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "MountPointId", + "Terraform": "mount_point_id" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DLF::Catalog", + "Terraform": null + }, + "ProductCode": "dlf", + "Name": { + "zh": "数据湖数据目录", + "en": "DLF Catalog" + }, + "Properties": [ + { + "ROS": "CatalogId", + "Terraform": null, + "Required": true + }, + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "LocationUri", + "Terraform": null, + "Required": false + }, + { + "ROS": "Owner", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "CatalogId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DMS::Instance", + "Terraform": "alicloud_dms_enterprise_instance" + }, + "ProductCode": "dms", + "Name": { + "zh": "DMS实例", + "en": "DMS Instance" + }, + "Properties": [ + { + "ROS": "DatabasePassword", + "Terraform": "database_password", + "Required": true + }, + { + "ROS": "DatabaseUser", + "Terraform": "database_user", + "Required": true + }, + { + "ROS": "DataLinkName", + "Terraform": "data_link_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "dba_id", + "Required": false + }, + { + "ROS": "DbaUid", + "Terraform": "dba_uid", + "Required": true + }, + { + "ROS": "DdlOnline", + "Terraform": "ddl_online", + "Required": false + }, + { + "ROS": "EcsInstanceId", + "Terraform": "ecs_instance_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Instance" + }, + { + "ResourceType": "ROS/ALIYUN::ECS::InstanceGroup" + } + ] + }, + { + "ROS": "EcsRegion", + "Terraform": "ecs_region", + "Required": false + }, + { + "ROS": "EnvType", + "Terraform": "env_type", + "Required": true + }, + { + "ROS": "ExportTimeout", + "Terraform": "export_timeout", + "Required": true + }, + { + "ROS": "Host", + "Terraform": "host", + "Required": true + }, + { + "ROS": "InstanceAlias", + "Terraform": null, + "Required": true + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_name", + "Required": false + }, + { + "ROS": "InstanceSource", + "Terraform": "instance_source", + "Required": true + }, + { + "ROS": "InstanceType", + "Terraform": "instance_type", + "Required": true + }, + { + "ROS": "NetworkType", + "Terraform": "network_type", + "Required": true + }, + { + "ROS": "Port", + "Terraform": "port", + "Required": true + }, + { + "ROS": "QueryTimeout", + "Terraform": "query_timeout", + "Required": true + }, + { + "ROS": "SafeRule", + "Terraform": "safe_rule", + "Required": true + }, + { + "ROS": null, + "Terraform": "safe_rule_id", + "Required": false + }, + { + "ROS": "Sid", + "Terraform": "sid", + "Required": false + }, + { + "ROS": null, + "Terraform": "skip_test", + "Required": false + }, + { + "ROS": "Tid", + "Terraform": "tid", + "Required": false + }, + { + "ROS": "UseDsql", + "Terraform": "use_dsql", + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "dba_nick_name" + }, + { + "ROS": "Host", + "Terraform": null + }, + { + "ROS": "InstanceId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "Port", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DMS::Instance2", + "Terraform": null + }, + "ProductCode": "dms", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "DatabasePassword", + "Terraform": null, + "Required": true + }, + { + "ROS": "DatabaseUser", + "Terraform": null, + "Required": true + }, + { + "ROS": "DataLinkName", + "Terraform": null, + "Required": false + }, + { + "ROS": "DbaId", + "Terraform": null, + "Required": true + }, + { + "ROS": "DdlOnline", + "Terraform": null, + "Required": false + }, + { + "ROS": "EcsInstanceId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Instance" + }, + { + "ResourceType": "ROS/ALIYUN::ECS::InstanceGroup" + } + ] + }, + { + "ROS": "EcsRegion", + "Terraform": null, + "Required": false + }, + { + "ROS": "EnableSellCommon", + "Terraform": null, + "Required": false + }, + { + "ROS": "EnableSellSitd", + "Terraform": null, + "Required": false + }, + { + "ROS": "EnableSellStable", + "Terraform": null, + "Required": false + }, + { + "ROS": "EnableSellTrust", + "Terraform": null, + "Required": true + }, + { + "ROS": "EnvType", + "Terraform": null, + "Required": true + }, + { + "ROS": "ExportTimeout", + "Terraform": null, + "Required": true + }, + { + "ROS": "Host", + "Terraform": null, + "Required": true + }, + { + "ROS": "InstanceAlias", + "Terraform": null, + "Required": true + }, + { + "ROS": "InstanceSource", + "Terraform": null, + "Required": true + }, + { + "ROS": "InstanceType", + "Terraform": null, + "Required": true + }, + { + "ROS": "NetworkType", + "Terraform": null, + "Required": true + }, + { + "ROS": "Port", + "Terraform": null, + "Required": true + }, + { + "ROS": "QueryTimeout", + "Terraform": null, + "Required": true + }, + { + "ROS": "SafeRule", + "Terraform": null, + "Required": true + }, + { + "ROS": "Sid", + "Terraform": null, + "Required": false + }, + { + "ROS": "SkipTest", + "Terraform": null, + "Required": false + }, + { + "ROS": "TemplateId", + "Terraform": null, + "Required": false + }, + { + "ROS": "TemplateType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Tid", + "Terraform": null, + "Required": false + }, + { + "ROS": "UseDsql", + "Terraform": null, + "Required": false + }, + { + "ROS": "UseSsl", + "Terraform": null, + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ], + "Attributes": [ + { + "ROS": "Host", + "Terraform": null + }, + { + "ROS": "InstanceId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Instance" + } + ] + }, + { + "ROS": "Port", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DMS::User", + "Terraform": "alicloud_dms_enterprise_user" + }, + "ProductCode": "dms", + "Name": { + "zh": "DMS User", + "en": "DMS User" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "max_execute_count", + "Required": false + }, + { + "ROS": null, + "Terraform": "max_result_count", + "Required": false + }, + { + "ROS": "Mobile", + "Terraform": "mobile", + "Required": false + }, + { + "ROS": "RoleNames", + "Terraform": "role_names", + "Required": false + }, + { + "ROS": "Status", + "Terraform": "status", + "Required": false + }, + { + "ROS": "Tid", + "Terraform": "tid", + "Required": false + }, + { + "ROS": "Uid", + "Terraform": "uid", + "Required": true + }, + { + "ROS": "UserName", + "Terraform": "user_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "UserId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "Mobile", + "Terraform": null + }, + { + "ROS": "ParentUid", + "Terraform": null + }, + { + "ROS": "RoleIds", + "Terraform": null + }, + { + "ROS": "RoleNames", + "Terraform": null + }, + { + "ROS": "Uid", + "Terraform": null + }, + { + "ROS": "UserName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DNS::Domain", + "Terraform": "alicloud_alidns_domain" + }, + "ProductCode": "dns", + "Name": { + "zh": "DNS域名", + "en": "DNS Domain" + }, + "Properties": [ + { + "ROS": "DomainName", + "Terraform": "domain_name", + "Required": true + }, + { + "ROS": "GroupId", + "Terraform": "group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::DNS::DomainGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "lang", + "Required": false + }, + { + "ROS": null, + "Terraform": "remark", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": "DnsServers", + "Terraform": "dns_servers" + }, + { + "ROS": "DomainId", + "Terraform": "domain_id" + }, + { + "ROS": "GroupId", + "Terraform": null + }, + { + "ROS": "GroupName", + "Terraform": "group_name" + }, + { + "ROS": "DomainName", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "PunyCode", + "Terraform": "puny_code" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DNS::DomainGroup", + "Terraform": "alicloud_alidns_domain_group" + }, + "ProductCode": "dns", + "Name": { + "zh": "DNS域名分组", + "en": "DNS Domain Group" + }, + "Properties": [ + { + "ROS": "GroupName", + "Terraform": "domain_group_name", + "Required": true + }, + { + "ROS": null, + "Terraform": "lang", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "GroupId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DNS::DomainRecord", + "Terraform": "alicloud_alidns_record" + }, + "ProductCode": "dns", + "Name": { + "zh": "DNS解析记录", + "en": "DNS Record" + }, + "Properties": [ + { + "ROS": "DomainName", + "Terraform": "domain_name", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::DNS::Domain" + } + ] + }, + { + "ROS": null, + "Terraform": "lang", + "Required": false + }, + { + "ROS": "Line", + "Terraform": "line", + "Required": false + }, + { + "ROS": "Priority", + "Terraform": "priority", + "Required": false + }, + { + "ROS": null, + "Terraform": "remark", + "Required": false + }, + { + "ROS": "RR", + "Terraform": "rr", + "Required": true + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": "TTL", + "Terraform": "ttl", + "Required": false + }, + { + "ROS": "Type", + "Terraform": "type", + "Required": true + }, + { + "ROS": null, + "Terraform": "user_client_ip", + "Required": false + }, + { + "ROS": "Value", + "Terraform": "value", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "RecordId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DNS::Instance", + "Terraform": "alicloud_alidns_instance" + }, + "ProductCode": "dns", + "Name": { + "zh": "DNS实例", + "en": "DNS Instance" + }, + "Properties": [ + { + "ROS": "DNSSecurity", + "Terraform": "dns_security", + "Required": false + }, + { + "ROS": "Domain", + "Terraform": null, + "Required": false + }, + { + "ROS": "DomainNumbers", + "Terraform": "domain_numbers", + "Required": true + }, + { + "ROS": "InstanceType", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": "Period", + "Terraform": "period", + "Required": true + }, + { + "ROS": "PeriodUnit", + "Terraform": null, + "Required": true + }, + { + "ROS": "RenewalStatus", + "Terraform": "renewal_status", + "Required": false + }, + { + "ROS": null, + "Terraform": "renew_period", + "Required": false + }, + { + "ROS": "Version", + "Terraform": null, + "Required": true + }, + { + "ROS": null, + "Terraform": "version_code", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "InstanceId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "InstanceId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "version_name" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DRDS::Account", + "Terraform": null + }, + "ProductCode": "drds", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "DbPrivileges", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "DbName", + "Terraform": null, + "Required": true + }, + { + "ROS": "Privilege", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "DrdsAccountName", + "Terraform": null, + "Required": true + }, + { + "ROS": "InstanceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::DRDS::DrdsInstance" + } + ] + }, + { + "ROS": "Password", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "AccountType", + "Terraform": null + }, + { + "ROS": "DbPrivileges", + "Terraform": null + }, + { + "ROS": "Description", + "Terraform": null + }, + { + "ROS": "DrdsAccountName", + "Terraform": null + }, + { + "ROS": "Host", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DRDS::DrdsDB", + "Terraform": null + }, + "ProductCode": "drds", + "Name": { + "zh": "PolarDB-X 1.0云原生分布式数据库", + "en": "PolarDB-X 1.0 Database" + }, + "Properties": [ + { + "ROS": "AccountName", + "Terraform": null, + "Required": false + }, + { + "ROS": "DbInstanceIsCreating", + "Terraform": null, + "Required": false + }, + { + "ROS": "DbInstType", + "Terraform": null, + "Required": false + }, + { + "ROS": "DbName", + "Terraform": null, + "Required": false + }, + { + "ROS": "DrdsInstanceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::DRDS::DrdsInstance" + } + ] + }, + { + "ROS": "Encode", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstDbName", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "DbInstanceId", + "Terraform": null, + "Required": true + }, + { + "ROS": "ShardDbName", + "Terraform": null, + "Required": true, + "Properties": {}, + "Type": "list" + } + ], + "Type": "list" + }, + { + "ROS": "Password", + "Terraform": null, + "Required": false + }, + { + "ROS": "RdsInstance", + "Terraform": null, + "Required": false, + "Properties": {}, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::RDS::DBInstance" + } + ], + "Type": "list" + }, + { + "ROS": "Type", + "Terraform": null, + "Required": false + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DRDS::DrdsInstance", + "Terraform": "alicloud_drds_instance" + }, + "ProductCode": "drds", + "Name": { + "zh": "PolarDB-X 1.0实例", + "en": "PolarDB-X 1.0 Instance" + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": "description", + "Required": true + }, + { + "ROS": "Duration", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_charge_type", + "Required": false + }, + { + "ROS": "InstanceSeries", + "Terraform": "instance_series", + "Required": true + }, + { + "ROS": "IsAutoRenew", + "Terraform": null, + "Required": false + }, + { + "ROS": "MySQLVersion", + "Terraform": "mysql_version", + "Required": false + }, + { + "ROS": "PayType", + "Terraform": null, + "Required": true + }, + { + "ROS": "PricingCycle", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "Specification", + "Terraform": "specification", + "Required": true + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "Type", + "Terraform": null, + "Required": true + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VswitchId", + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "ZoneId", + "Terraform": "zone_id", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "connection_string" + }, + { + "ROS": "DrdsInstanceId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "InternetEndpoint", + "Terraform": null + }, + { + "ROS": "IntranetEndpoint", + "Terraform": null + }, + { + "ROS": "OrderId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "port" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DTS::ConsumerGroup", + "Terraform": null + }, + "ProductCode": "dts", + "Name": { + "zh": "DTS ConsumerGroup", + "en": "DTS Consumer Group" + }, + "Properties": [ + { + "ROS": "ConsumerGroupName", + "Terraform": null, + "Required": true + }, + { + "ROS": "ConsumerGroupPassword", + "Terraform": null, + "Required": true + }, + { + "ROS": "ConsumerGroupUserName", + "Terraform": null, + "Required": true + }, + { + "ROS": "SubscriptionInstanceId", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "ConsumerGroupID", + "Terraform": null, + "Primary": true + }, + { + "ROS": "ConsumerGroupName", + "Terraform": null + }, + { + "ROS": "SubscriptionInstanceId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DTS::Instance", + "Terraform": "alicloud_dts_instance" + }, + "ProductCode": "dts", + "Name": { + "zh": "DTS实例", + "en": "DTS Instance" + }, + "Properties": [ + { + "ROS": "AutoPay", + "Terraform": "auto_pay", + "Required": false + }, + { + "ROS": "AutoStart", + "Terraform": "auto_start", + "Required": false + }, + { + "ROS": "ComputeUnit", + "Terraform": "compute_unit", + "Required": false + }, + { + "ROS": "DatabaseCount", + "Terraform": "database_count", + "Required": false + }, + { + "ROS": "DestinationEndpointEngineName", + "Terraform": "destination_endpoint_engine_name", + "Required": false + }, + { + "ROS": "DestinationRegion", + "Terraform": "destination_region", + "Required": false + }, + { + "ROS": "Du", + "Terraform": "du", + "Required": false + }, + { + "ROS": "FeeType", + "Terraform": "fee_type", + "Required": false + }, + { + "ROS": "InstanceClass", + "Terraform": "instance_class", + "Required": true + }, + { + "ROS": "JobId", + "Terraform": "job_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": "PayType", + "Terraform": null, + "Required": true + }, + { + "ROS": "Period", + "Terraform": "period", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "SourceEndpointEngineName", + "Terraform": "source_endpoint_engine_name", + "Required": false + }, + { + "ROS": "SourceRegion", + "Terraform": "source_region", + "Required": false + }, + { + "ROS": "SyncArchitecture", + "Terraform": "sync_architecture", + "Required": false + }, + { + "ROS": null, + "Terraform": "synchronization_direction", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": "Type", + "Terraform": "type", + "Required": true + }, + { + "ROS": "UsedTime", + "Terraform": "used_time", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "dts_instance_id" + }, + { + "ROS": "InstanceId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "instance_name" + }, + { + "ROS": "JobId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DTS::MigrationJob2", + "Terraform": "alicloud_dts_migration_job" + }, + "ProductCode": "dts", + "Name": { + "zh": "DTS MigrationJob2", + "en": "DTS Migration Job 2" + }, + "Properties": [ + { + "ROS": "Checkpoint", + "Terraform": "checkpoint", + "Required": false + }, + { + "ROS": "DataCheckConfigure", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "checkMaximumHour", + "Terraform": null, + "Required": false + }, + { + "ROS": "checkMaximumHourEnable", + "Terraform": null, + "Required": false + }, + { + "ROS": "dataCheckDbList", + "Terraform": null, + "Required": false + }, + { + "ROS": "dataCheckNoticePhone", + "Terraform": null, + "Required": false + }, + { + "ROS": "fullCheckErrorNotice", + "Terraform": null, + "Required": false + }, + { + "ROS": "fullCheckFixData", + "Terraform": null, + "Required": false + }, + { + "ROS": "fullCheckMaxReadBps", + "Terraform": null, + "Required": false + }, + { + "ROS": "fullCheckMaxReadRps", + "Terraform": null, + "Required": false + }, + { + "ROS": "fullCheckModel", + "Terraform": null, + "Required": false + }, + { + "ROS": "fullCheckNoticeValue", + "Terraform": null, + "Required": false + }, + { + "ROS": "fullCheckRatio", + "Terraform": null, + "Required": false + }, + { + "ROS": "fullCheckReferEndpoint", + "Terraform": null, + "Required": false + }, + { + "ROS": "fullCheckValidFailNotice", + "Terraform": null, + "Required": false + }, + { + "ROS": "fullDataCheck", + "Terraform": null, + "Required": false + }, + { + "ROS": "incrementalCheckDelayNotice", + "Terraform": null, + "Required": false + }, + { + "ROS": "incrementalCheckDelayNoticePeriod", + "Terraform": null, + "Required": false + }, + { + "ROS": "incrementalCheckDelayNoticeTimes", + "Terraform": null, + "Required": false + }, + { + "ROS": "incrementalCheckDelayNoticeValue", + "Terraform": null, + "Required": false + }, + { + "ROS": "incrementalCheckErrorNotice", + "Terraform": null, + "Required": false + }, + { + "ROS": "incrementalCheckValidFailNotice", + "Terraform": null, + "Required": false + }, + { + "ROS": "incrementalCheckValidFailNoticePeriod", + "Terraform": null, + "Required": false + }, + { + "ROS": "incrementalCheckValidFailNoticeTimes", + "Terraform": null, + "Required": false + }, + { + "ROS": "incrementalCheckValidFailNoticeValue", + "Terraform": null, + "Required": false + }, + { + "ROS": "incrementalDataCheck", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "DataInitialization", + "Terraform": "data_initialization", + "Required": true + }, + { + "ROS": "DataSynchronization", + "Terraform": "data_synchronization", + "Required": true + }, + { + "ROS": "DbList", + "Terraform": "db_list", + "Required": true + }, + { + "ROS": "DedicatedClusterId", + "Terraform": null, + "Required": false + }, + { + "ROS": "DelayNotice", + "Terraform": null, + "Required": false + }, + { + "ROS": "DelayPhone", + "Terraform": null, + "Required": false + }, + { + "ROS": "DelayRuleTime", + "Terraform": null, + "Required": false + }, + { + "ROS": "DestinationEndpoint.DatabaseName", + "Terraform": "destination_endpoint_database_name", + "Required": false + }, + { + "ROS": "DestinationEndpoint.EngineName", + "Terraform": "destination_endpoint_engine_name", + "Required": false + }, + { + "ROS": "DestinationEndpoint.InstanceID", + "Terraform": "destination_endpoint_instance_id", + "Required": false + }, + { + "ROS": "DestinationEndpoint.InstanceType", + "Terraform": "destination_endpoint_instance_type", + "Required": false + }, + { + "ROS": "DestinationEndpoint.IP", + "Terraform": "destination_endpoint_ip", + "Required": false + }, + { + "ROS": "DestinationEndpoint.OracleSID", + "Terraform": "destination_endpoint_oracle_sid", + "Required": false + }, + { + "ROS": "DestinationEndpoint.Password", + "Terraform": "destination_endpoint_password", + "Required": false + }, + { + "ROS": "DestinationEndpoint.Port", + "Terraform": "destination_endpoint_port", + "Required": false + }, + { + "ROS": "DestinationEndpoint.Region", + "Terraform": "destination_endpoint_region", + "Required": false + }, + { + "ROS": "DestinationEndpoint.UserName", + "Terraform": "destination_endpoint_user_name", + "Required": false + }, + { + "ROS": "DisasterRecoveryJob", + "Terraform": null, + "Required": false + }, + { + "ROS": "DtsBisLabel", + "Terraform": null, + "Required": false + }, + { + "ROS": "DtsInstanceId", + "Terraform": "dts_instance_id", + "Required": false + }, + { + "ROS": "DtsJobId", + "Terraform": null, + "Required": false + }, + { + "ROS": "DtsJobName", + "Terraform": "dts_job_name", + "Required": true + }, + { + "ROS": "ErrorNotice", + "Terraform": null, + "Required": false + }, + { + "ROS": "ErrorPhone", + "Terraform": null, + "Required": false + }, + { + "ROS": "FileOssUrl", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_class", + "Required": false + }, + { + "ROS": "Reserve", + "Terraform": null, + "Required": false + }, + { + "ROS": "SourceEndpoint.DatabaseName", + "Terraform": "source_endpoint_database_name", + "Required": false + }, + { + "ROS": "SourceEndpoint.EngineName", + "Terraform": "source_endpoint_engine_name", + "Required": false + }, + { + "ROS": "SourceEndpoint.InstanceID", + "Terraform": "source_endpoint_instance_id", + "Required": false + }, + { + "ROS": "SourceEndpoint.InstanceType", + "Terraform": "source_endpoint_instance_type", + "Required": false + }, + { + "ROS": "SourceEndpoint.IP", + "Terraform": "source_endpoint_ip", + "Required": false + }, + { + "ROS": "SourceEndpoint.OracleSID", + "Terraform": "source_endpoint_oracle_sid", + "Required": false + }, + { + "ROS": "SourceEndpoint.OwnerID", + "Terraform": "source_endpoint_owner_id", + "Required": false + }, + { + "ROS": "SourceEndpoint.Password", + "Terraform": "source_endpoint_password", + "Required": false + }, + { + "ROS": "SourceEndpoint.Port", + "Terraform": "source_endpoint_port", + "Required": false + }, + { + "ROS": "SourceEndpoint.Region", + "Terraform": "source_endpoint_region", + "Required": false + }, + { + "ROS": "SourceEndpoint.Role", + "Terraform": "source_endpoint_role", + "Required": false + }, + { + "ROS": "SourceEndpoint.UserName", + "Terraform": "source_endpoint_user_name", + "Required": false + }, + { + "ROS": "Status", + "Terraform": "status", + "Required": false + }, + { + "ROS": "StructureInitialization", + "Terraform": "structure_initialization", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "DtsInstanceId", + "Terraform": null + }, + { + "ROS": "DtsJobName", + "Terraform": null + }, + { + "ROS": "DtsJobId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DTS::SubscriptionJob2", + "Terraform": null + }, + "ProductCode": "dts", + "Name": { + "zh": "DTS SubscriptionJob2", + "en": "DTS Subscription Job 2" + }, + "Properties": [ + { + "ROS": "Checkpoint", + "Terraform": null, + "Required": false + }, + { + "ROS": "DbList", + "Terraform": null, + "Required": true + }, + { + "ROS": "DedicatedClusterId", + "Terraform": null, + "Required": false + }, + { + "ROS": "DelayNotice", + "Terraform": null, + "Required": false + }, + { + "ROS": "DelayPhone", + "Terraform": null, + "Required": false + }, + { + "ROS": "DelayRuleTime", + "Terraform": null, + "Required": false + }, + { + "ROS": "DtsBisLabel", + "Terraform": null, + "Required": false + }, + { + "ROS": "DtsInstanceId", + "Terraform": null, + "Required": false + }, + { + "ROS": "DtsJobId", + "Terraform": null, + "Required": false + }, + { + "ROS": "DtsJobName", + "Terraform": null, + "Required": true + }, + { + "ROS": "ErrorNotice", + "Terraform": null, + "Required": false + }, + { + "ROS": "ErrorPhone", + "Terraform": null, + "Required": false + }, + { + "ROS": "Reserve", + "Terraform": null, + "Required": false + }, + { + "ROS": "SourceEndpoint", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "DatabaseName", + "Terraform": null, + "Required": false + }, + { + "ROS": "EngineName", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceID", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceType", + "Terraform": null, + "Required": false + }, + { + "ROS": "IP", + "Terraform": null, + "Required": false + }, + { + "ROS": "OracleSID", + "Terraform": null, + "Required": false + }, + { + "ROS": "OwnerID", + "Terraform": null, + "Required": false + }, + { + "ROS": "Password", + "Terraform": null, + "Required": false + }, + { + "ROS": "Port", + "Terraform": null, + "Required": false + }, + { + "ROS": "Region", + "Terraform": null, + "Required": false + }, + { + "ROS": "Role", + "Terraform": null, + "Required": false + }, + { + "ROS": "UserName", + "Terraform": null, + "Required": false + }, + { + "ROS": "VSwitchID", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ] + }, + { + "ROS": "Status", + "Terraform": null, + "Required": false + }, + { + "ROS": "SubscriptionDataType", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "DDL", + "Terraform": null, + "Required": false + }, + { + "ROS": "DML", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "SubscriptionInstance", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "NetworkType", + "Terraform": null, + "Required": true + }, + { + "ROS": "VPCId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ] + } + ], + "Attributes": [ + { + "ROS": "DtsInstanceId", + "Terraform": null + }, + { + "ROS": "DtsJobId", + "Terraform": null + }, + { + "ROS": "DtsJobName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DTS::SynchronizationJob2", + "Terraform": "alicloud_dts_synchronization_job" + }, + "ProductCode": "dts", + "Name": { + "zh": "DTS SynchronizationJob2", + "en": "DTS Synchronization Job 2" + }, + "Properties": [ + { + "ROS": "Checkpoint", + "Terraform": "checkpoint", + "Required": false + }, + { + "ROS": "DataCheckConfigure", + "Terraform": "data_check_configure", + "Required": false + }, + { + "ROS": "DataInitialization", + "Terraform": "data_initialization", + "Required": true + }, + { + "ROS": "DataSynchronization", + "Terraform": "data_synchronization", + "Required": true + }, + { + "ROS": "DbList", + "Terraform": "db_list", + "Required": true + }, + { + "ROS": "DedicatedClusterId", + "Terraform": "dedicated_cluster_id", + "Required": false + }, + { + "ROS": "DelayNotice", + "Terraform": "delay_notice", + "Required": false + }, + { + "ROS": "DelayPhone", + "Terraform": "delay_phone", + "Required": false + }, + { + "ROS": "DelayRuleTime", + "Terraform": "delay_rule_time", + "Required": false + }, + { + "ROS": "DestinationEndpoint.DatabaseName", + "Terraform": "destination_endpoint_database_name", + "Required": false + }, + { + "ROS": "DestinationEndpoint.InstanceTypeForCreation", + "Terraform": "destination_endpoint_engine_name", + "Required": false + }, + { + "ROS": "DestinationEndpoint.InstanceId", + "Terraform": "destination_endpoint_instance_id", + "Required": false + }, + { + "ROS": "DestinationEndpoint.InstanceType", + "Terraform": "destination_endpoint_instance_type", + "Required": false + }, + { + "ROS": "DestinationEndpoint.IP", + "Terraform": "destination_endpoint_ip", + "Required": false + }, + { + "ROS": "DestinationEndpoint.OracleSID", + "Terraform": "destination_endpoint_oracle_sid", + "Required": false + }, + { + "ROS": "DestinationEndpoint.OwnerID", + "Terraform": "destination_endpoint_owner_id", + "Required": false + }, + { + "ROS": "DestinationEndpoint.Password", + "Terraform": "destination_endpoint_password", + "Required": false + }, + { + "ROS": "DestinationEndpoint.Port", + "Terraform": "destination_endpoint_port", + "Required": false + }, + { + "ROS": "DestinationEndpoint.Region", + "Terraform": "destination_endpoint_region", + "Required": false + }, + { + "ROS": "DestinationEndpoint.Role", + "Terraform": "destination_endpoint_role", + "Required": false + }, + { + "ROS": "DestinationEndpoint.UserName", + "Terraform": "destination_endpoint_user_name", + "Required": false + }, + { + "ROS": "DisasterRecoveryJob", + "Terraform": null, + "Required": false + }, + { + "ROS": "DtsBisLabel", + "Terraform": "dts_bis_label", + "Required": false + }, + { + "ROS": "DtsInstanceId", + "Terraform": "dts_instance_id", + "Required": false + }, + { + "ROS": "DtsJobId", + "Terraform": null, + "Required": false + }, + { + "ROS": "DtsJobName", + "Terraform": "dts_job_name", + "Required": true + }, + { + "ROS": "ErrorNotice", + "Terraform": "error_notice", + "Required": false + }, + { + "ROS": "ErrorPhone", + "Terraform": "error_phone", + "Required": false + }, + { + "ROS": "FileOssUrl", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_class", + "Required": false + }, + { + "ROS": "Reserve", + "Terraform": "reserve", + "Required": false + }, + { + "ROS": "SourceEndpoint.DatabaseName", + "Terraform": "source_endpoint_database_name", + "Required": false + }, + { + "ROS": "SourceEndpoint.InstanceTypeForCreation", + "Terraform": "source_endpoint_engine_name", + "Required": false + }, + { + "ROS": "SourceEndpoint.InstanceId", + "Terraform": "source_endpoint_instance_id", + "Required": false + }, + { + "ROS": "SourceEndpoint.InstanceType", + "Terraform": "source_endpoint_instance_type", + "Required": false + }, + { + "ROS": "SourceEndpoint.IP", + "Terraform": "source_endpoint_ip", + "Required": false + }, + { + "ROS": "SourceEndpoint.OracleSID", + "Terraform": "source_endpoint_oracle_sid", + "Required": false + }, + { + "ROS": "SourceEndpoint.OwnerID", + "Terraform": "source_endpoint_owner_id", + "Required": false + }, + { + "ROS": "SourceEndpoint.Password", + "Terraform": "source_endpoint_password", + "Required": false + }, + { + "ROS": "SourceEndpoint.Port", + "Terraform": "source_endpoint_port", + "Required": false + }, + { + "ROS": "SourceEndpoint.Region", + "Terraform": "source_endpoint_region", + "Required": false + }, + { + "ROS": "SourceEndpoint.Role", + "Terraform": "source_endpoint_role", + "Required": false + }, + { + "ROS": "SourceEndpoint.UserName", + "Terraform": "source_endpoint_user_name", + "Required": false + }, + { + "ROS": "SourceEndpoint.VSwitchID", + "Terraform": "source_endpoint_vswitch_id", + "Required": false + }, + { + "ROS": "Status", + "Terraform": "status", + "Required": false + }, + { + "ROS": "StructureInitialization", + "Terraform": "structure_initialization", + "Required": true + }, + { + "ROS": "SynchronizationDirection", + "Terraform": "synchronization_direction", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "DtsJobId", + "Terraform": null + }, + { + "ROS": "DtsJobName", + "Terraform": null + }, + { + "ROS": "DtsInstanceId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DashVector::Cluster", + "Terraform": null + }, + "ProductCode": "dashvector", + "Name": { + "zh": "DashVector Cluster", + "en": "DashVector Cluster" + }, + "Properties": [ + { + "ROS": "ClusterName", + "Terraform": null, + "Required": true + }, + { + "ROS": "ClusterType", + "Terraform": null, + "Required": true + }, + { + "ROS": "IgnoreExisting", + "Terraform": null, + "Required": false + }, + { + "ROS": "ReplicaCount", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "ClusterName", + "Terraform": null + }, + { + "ROS": "Endpoint", + "Terraform": null + }, + { + "ROS": "InstanceId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DataWorks::Project", + "Terraform": "alicloud_data_works_project" + }, + "ProductCode": "dide", + "Name": { + "zh": "DataWorks Project", + "en": "DataWorks Project" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": "DisableDevelopment", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "display_name", + "Required": false + }, + { + "ROS": "IsAllowDownload", + "Terraform": null, + "Required": false + }, + { + "ROS": "ProjectDescription", + "Terraform": null, + "Required": false + }, + { + "ROS": "ProjectIdentifier", + "Terraform": null, + "Required": true + }, + { + "ROS": "ProjectMode", + "Terraform": "project_mode", + "Required": false + }, + { + "ROS": "ProjectName", + "Terraform": "project_name", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "EnvTypes", + "Terraform": null + }, + { + "ROS": "ProjectId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "IsDefault", + "Terraform": null + }, + { + "ROS": "ProjectIdentifier", + "Terraform": null + }, + { + "ROS": "ProtectedMode", + "Terraform": null + }, + { + "ROS": "ResidentArea", + "Terraform": null + }, + { + "ROS": "SchedulerMaxRetryTimes", + "Terraform": null + }, + { + "ROS": "SchedulerRetryInterval", + "Terraform": null + }, + { + "ROS": "TablePrivacyMode", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DirectMail::Domain", + "Terraform": "alicloud_direct_mail_domain" + }, + "ProductCode": "directmail", + "Name": { + "zh": "DirectMail Domain", + "en": "Direct Mail Domain" + }, + "Properties": [ + { + "ROS": "DomainName", + "Terraform": "domain_name", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "CnameAuthStatus", + "Terraform": null + }, + { + "ROS": "CnameConfirmStatus", + "Terraform": null + }, + { + "ROS": "CnameRecord", + "Terraform": null + }, + { + "ROS": "CreateTime", + "Terraform": null + }, + { + "ROS": "DefaultDomain", + "Terraform": null + }, + { + "ROS": "DnsMx", + "Terraform": null + }, + { + "ROS": "DnsSpf", + "Terraform": null + }, + { + "ROS": "DnsTxt", + "Terraform": null + }, + { + "ROS": "DomainName", + "Terraform": null + }, + { + "ROS": "DomainType", + "Terraform": null + }, + { + "ROS": "IcpStatus", + "Terraform": null + }, + { + "ROS": "DomainId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "MxAuthStatus", + "Terraform": null + }, + { + "ROS": "MxRecord", + "Terraform": null + }, + { + "ROS": "SpfAuthStatus", + "Terraform": null + }, + { + "ROS": "SpfRecord", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "TlDomainName", + "Terraform": null + }, + { + "ROS": "TracefRecord", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::DirectMail::Ipfilter", + "Terraform": null + }, + "ProductCode": "directmail", + "Name": { + "zh": "DirectMail Ipfilter", + "en": "Direct Mail IP Filter" + }, + "Properties": [ + { + "ROS": "IpAddress", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "CreateTime", + "Terraform": null + }, + { + "ROS": "IpAddress", + "Terraform": null + }, + { + "ROS": "IpfilterId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::EAIS::ClientInstanceAttachment", + "Terraform": null + }, + "ProductCode": "eais", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "ClientInstanceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::EAIS::Instance" + } + ] + }, + { + "ROS": "InstanceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::EAIS::Instance" + } + ] + } + ], + "Attributes": [ + { + "ROS": "ClientInstanceId", + "Terraform": null + }, + { + "ROS": "InstanceId", + "Terraform": null + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::EAIS::Instance", + "Terraform": "alicloud_eais_instance" + }, + "ProductCode": "eais", + "Name": { + "zh": "EAIS实例", + "en": "EAIS Instance" + }, + "Properties": [ + { + "ROS": "CreateWithNotebook", + "Terraform": null, + "Required": true + }, + { + "ROS": "EnvironmentVar", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": false + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": null, + "Terraform": "force", + "Required": false + }, + { + "ROS": "InstanceName", + "Terraform": "instance_name", + "Required": false + }, + { + "ROS": "InstanceType", + "Terraform": "instance_type", + "Required": true + }, + { + "ROS": "PaymentType", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "SecurityGroupId", + "Terraform": "security_group_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Attributes": [ + { + "ROS": "ClientInstanceId", + "Terraform": null + }, + { + "ROS": "ClientInstanceName", + "Terraform": null + }, + { + "ROS": "ClientInstanceType", + "Terraform": null + }, + { + "ROS": "CreateTime", + "Terraform": null + }, + { + "ROS": "InstanceId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "InstanceName", + "Terraform": null + }, + { + "ROS": "InstanceType", + "Terraform": null + }, + { + "ROS": "JupyterUrl", + "Terraform": null + }, + { + "ROS": "ResourceGroupId", + "Terraform": null + }, + { + "ROS": "SecurityGroupId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "ZoneId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::EBS::DedicatedBlockStorageCluster", + "Terraform": "alicloud_ebs_dedicated_block_storage_cluster" + }, + "ProductCode": "disk", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "Azone", + "Terraform": null, + "Required": true + }, + { + "ROS": "Capacity", + "Terraform": null, + "Required": true + }, + { + "ROS": "DbscName", + "Terraform": null, + "Required": true + }, + { + "ROS": null, + "Terraform": "dedicated_block_storage_cluster_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": "Period", + "Terraform": null, + "Required": true + }, + { + "ROS": "PeriodUnit", + "Terraform": null, + "Required": true + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false + }, + { + "ROS": "Tag", + "Terraform": null, + "Required": false, + "Type": "list", + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": null, + "Terraform": "total_capacity", + "Required": false + }, + { + "ROS": "Type", + "Terraform": "type", + "Required": true + }, + { + "ROS": null, + "Terraform": "zone_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "available_capacity" + }, + { + "ROS": null, + "Terraform": "category" + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "DedicatedBlockStorageClusterId", + "Terraform": "dedicated_block_storage_cluster_id" + }, + { + "ROS": null, + "Terraform": "delivery_capacity" + }, + { + "ROS": null, + "Terraform": "description" + }, + { + "ROS": null, + "Terraform": "expired_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "performance_level" + }, + { + "ROS": null, + "Terraform": "resource_group_id" + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": null, + "Terraform": "supported_category" + }, + { + "ROS": null, + "Terraform": "used_capacity" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::EBS::DiskReplicaGroup", + "Terraform": "alicloud_ebs_disk_replica_group" + }, + "ProductCode": "disk", + "Name": { + "zh": "EBS一致性复制组", + "en": "EBS Replication Pair-consistent Group" + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "DestinationRegionId", + "Terraform": "destination_region_id", + "Required": true + }, + { + "ROS": "DestinationZoneId", + "Terraform": "destination_zone_id", + "Required": true + }, + { + "ROS": "DiskReplicaGroupName", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "group_name", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "RPO", + "Terraform": "rpo", + "Required": false + }, + { + "ROS": "SourceRegionId", + "Terraform": "source_region_id", + "Required": true + }, + { + "ROS": "SourceZoneId", + "Terraform": "source_zone_id", + "Required": true + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "Description", + "Terraform": null + }, + { + "ROS": "DestinationRegionId", + "Terraform": null + }, + { + "ROS": "DestinationZoneId", + "Terraform": null + }, + { + "ROS": "DiskReplicaGroupName", + "Terraform": null + }, + { + "ROS": "ReplicaGroupId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "LastRecoverPoint", + "Terraform": null + }, + { + "ROS": "PairIds", + "Terraform": null + }, + { + "ROS": "PairNumber", + "Terraform": null + }, + { + "ROS": "PrimaryRegion", + "Terraform": null + }, + { + "ROS": "PrimaryZone", + "Terraform": null + }, + { + "ROS": "ResourceGroupId", + "Terraform": null + }, + { + "ROS": "RPO", + "Terraform": null + }, + { + "ROS": "Site", + "Terraform": null + }, + { + "ROS": "SourceRegionId", + "Terraform": null + }, + { + "ROS": "SourceZoneId", + "Terraform": null + }, + { + "ROS": "StandbyRegion", + "Terraform": null + }, + { + "ROS": "StandbyZone", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "Tags", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::EBS::DiskReplicaPair", + "Terraform": "alicloud_ebs_disk_replica_pair" + }, + "ProductCode": "disk", + "Name": { + "zh": "EBS复制对", + "en": "EBS Replication Pair" + }, + "Properties": [ + { + "ROS": "Bandwidth", + "Terraform": "bandwidth", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "DestinationDiskId", + "Terraform": "destination_disk_id", + "Required": true + }, + { + "ROS": "DestinationRegionId", + "Terraform": "destination_region_id", + "Required": true + }, + { + "ROS": "DestinationZoneId", + "Terraform": "destination_zone_id", + "Required": true + }, + { + "ROS": "DiskId", + "Terraform": "disk_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Disk" + } + ] + }, + { + "ROS": "DiskReplicaPairName", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "pair_name", + "Required": false + }, + { + "ROS": "PaymentType", + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": "Period", + "Terraform": "period", + "Required": false + }, + { + "ROS": "PeriodUnit", + "Terraform": "period_unit", + "Required": false + }, + { + "ROS": null, + "Terraform": "replica_pair_id", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "RPO", + "Terraform": "rpo", + "Required": false + }, + { + "ROS": "SourceZoneId", + "Terraform": "source_zone_id", + "Required": true + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "Bandwidth", + "Terraform": null + }, + { + "ROS": "CreateTime", + "Terraform": "create_time" + }, + { + "ROS": "Description", + "Terraform": null + }, + { + "ROS": "DestinationDiskId", + "Terraform": null + }, + { + "ROS": "DestinationRegionId", + "Terraform": null + }, + { + "ROS": "DestinationZoneId", + "Terraform": null + }, + { + "ROS": "DiskId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Disk" + } + ] + }, + { + "ROS": "DiskReplicaPairName", + "Terraform": null + }, + { + "ROS": "ReplicaPairId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "PaymentType", + "Terraform": null + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id" + }, + { + "ROS": "RPO", + "Terraform": null + }, + { + "ROS": "SourceZoneId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "Tags", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::EBS::DiskReplicaPairAddition", + "Terraform": null + }, + "ProductCode": "disk", + "Name": { + "zh": "添加EBS复制对", + "en": "Add EBS Replication Pair" + }, + "Properties": [ + { + "ROS": "ReplicaGroupId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::EBS::DiskReplicaGroup" + } + ] + }, + { + "ROS": "ReplicaPairId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::EBS::DiskReplicaPair" + } + ] + } + ], + "Attributes": [ + { + "ROS": "ReplicaGroupId", + "Terraform": null + }, + { + "ROS": "ReplicaPairId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECD::Bundle", + "Terraform": "alicloud_ecd_bundle" + }, + "ProductCode": "ecd", + "Name": { + "zh": "ECD Bundle", + "en": "EDS Template" + }, + "Properties": [ + { + "ROS": "BundleName", + "Terraform": "bundle_name", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "DesktopType", + "Terraform": "desktop_type", + "Required": true + }, + { + "ROS": "ImageId", + "Terraform": "image_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::CustomImage" + } + ] + }, + { + "ROS": "Language", + "Terraform": "language", + "Required": false + }, + { + "ROS": "RootDiskPerformanceLevel", + "Terraform": "root_disk_performance_level", + "Required": false + }, + { + "ROS": "RootDiskSizeGib", + "Terraform": "root_disk_size_gib", + "Required": true + }, + { + "ROS": "UserDiskPerformanceLevel", + "Terraform": "user_disk_performance_level", + "Required": false + }, + { + "ROS": "UserDiskSizeGib", + "Terraform": "user_disk_size_gib", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "BundleId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECD::DesktopGroup", + "Terraform": null + }, + "ProductCode": "ecd", + "Name": { + "zh": "ECD DesktopGroup", + "en": "EDS Cloud Computer Pool" + }, + "Properties": [ + { + "ROS": "AllowAutoSetup", + "Terraform": null, + "Required": false + }, + { + "ROS": "AllowBufferCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "AutoPay", + "Terraform": null, + "Required": false + }, + { + "ROS": "AutoRenew", + "Terraform": null, + "Required": false + }, + { + "ROS": "BundleId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECD::Bundle" + } + ] + }, + { + "ROS": "BuyDesktopsCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "ChargeType", + "Terraform": null, + "Required": true + }, + { + "ROS": "Comments", + "Terraform": null, + "Required": false + }, + { + "ROS": "ConnectDuration", + "Terraform": null, + "Required": false + }, + { + "ROS": "DefaultInitDesktopCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "DesktopGroupName", + "Terraform": null, + "Required": false + }, + { + "ROS": "EndUserIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "GroupVersion", + "Terraform": null, + "Required": false + }, + { + "ROS": "IdleDisconnectDuration", + "Terraform": null, + "Required": false + }, + { + "ROS": "KeepDuration", + "Terraform": null, + "Required": false + }, + { + "ROS": "MaxDesktopsCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "MinDesktopsCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "OfficeSiteId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECD::SimpleOfficeSite" + } + ] + }, + { + "ROS": "Period", + "Terraform": null, + "Required": false + }, + { + "ROS": "PeriodUnit", + "Terraform": null, + "Required": false + }, + { + "ROS": "PolicyGroupId", + "Terraform": null, + "Required": true + }, + { + "ROS": "ResetType", + "Terraform": null, + "Required": false + }, + { + "ROS": "StopDuration", + "Terraform": null, + "Required": false + }, + { + "ROS": "VolumeEncryptionEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "VolumeEncryptionKey", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "DesktopGroupId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECD::Desktops", + "Terraform": "alicloud_ecd_desktop" + }, + "ProductCode": "ecd", + "Name": { + "zh": "ECD Desktops", + "en": "EDS Cloud Computers" + }, + "Properties": [ + { + "ROS": "Amount", + "Terraform": "amount", + "Required": false + }, + { + "ROS": "AutoPay", + "Terraform": "auto_pay", + "Required": false + }, + { + "ROS": "AutoRenew", + "Terraform": "auto_renew", + "Required": false + }, + { + "ROS": "BundleId", + "Terraform": "bundle_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECD::Bundle" + } + ] + }, + { + "ROS": "DesktopName", + "Terraform": "desktop_name", + "Required": false + }, + { + "ROS": "DesktopNameSuffix", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "desktop_type", + "Required": false + }, + { + "ROS": "DirectoryId", + "Terraform": null, + "Required": false + }, + { + "ROS": "EndUserId", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "end_user_ids", + "Required": false + }, + { + "ROS": "GroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECD::DesktopGroup" + } + ] + }, + { + "ROS": "Hostname", + "Terraform": "host_name", + "Required": false + }, + { + "ROS": "OfficeSiteId", + "Terraform": "office_site_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECD::SimpleOfficeSite" + } + ] + }, + { + "ROS": "ChargeType", + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": "Period", + "Terraform": "period", + "Required": false + }, + { + "ROS": "PeriodUnit", + "Terraform": "period_unit", + "Required": false + }, + { + "ROS": "PolicyGroupId", + "Terraform": "policy_group_id", + "Required": true + }, + { + "ROS": "PromotionId", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "root_disk_size_gib", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": null, + "Terraform": "stopped_mode", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "UserAssignMode", + "Terraform": "user_assign_mode", + "Required": false + }, + { + "ROS": null, + "Terraform": "user_disk_size_gib", + "Required": false + }, + { + "ROS": "UserName", + "Terraform": null, + "Required": false + }, + { + "ROS": "VolumeEncryptionEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "VolumeEncryptionKey", + "Terraform": null, + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ], + "Attributes": [ + { + "ROS": "DesktopId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "OrderId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECD::NetworkPackage", + "Terraform": "alicloud_ecd_network_package" + }, + "ProductCode": "ecd", + "Name": { + "zh": "ECD NetworkPackage", + "en": "EDS Bandwidth Plan" + }, + "Properties": [ + { + "ROS": "AutoPay", + "Terraform": null, + "Required": false + }, + { + "ROS": "AutoRenew", + "Terraform": null, + "Required": false + }, + { + "ROS": "Bandwidth", + "Terraform": "bandwidth", + "Required": true + }, + { + "ROS": "InternetChargeType", + "Terraform": "internet_charge_type", + "Required": false + }, + { + "ROS": "OfficeSiteId", + "Terraform": "office_site_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECD::SimpleOfficeSite" + } + ] + }, + { + "ROS": "PayType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Period", + "Terraform": null, + "Required": false + }, + { + "ROS": "PeriodUnit", + "Terraform": null, + "Required": false + }, + { + "ROS": "PromotionId", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "NetworkPackageId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECD::NetworkPackageAssociation", + "Terraform": null + }, + "MainResourceType": { + "ResourceType": "ROS/ALIYUN::ECD::NetworkPackage", + "RefProperty": "ROS/NetworkPackageId" + }, + "ProductCode": "ecd", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "NetworkPackageId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECD::NetworkPackage" + } + ] + }, + { + "ROS": "OfficeSiteId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECD::SimpleOfficeSite" + } + ] + } + ], + "Attributes": [ + { + "ROS": "NetworkPackageId", + "Terraform": null + }, + { + "ROS": "OfficeSiteId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECD::SimpleOfficeSite", + "Terraform": "alicloud_ecd_simple_office_site" + }, + "ProductCode": "ecd", + "Name": { + "zh": "ECD SimpleOfficeSite", + "en": "EDS Convenience Account Office Network" + }, + "Properties": [ + { + "ROS": "Bandwidth", + "Terraform": null, + "Required": false + }, + { + "ROS": "CenId", + "Terraform": "cen_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::CenInstance" + } + ] + }, + { + "ROS": "CenOwnerId", + "Terraform": "cen_owner_id", + "Required": false + }, + { + "ROS": "CidrBlock", + "Terraform": "cidr_block", + "Required": false + }, + { + "ROS": "CloudBoxOfficeSite", + "Terraform": null, + "Required": false + }, + { + "ROS": "DesktopAccessType", + "Terraform": "desktop_access_type", + "Required": false + }, + { + "ROS": "EnableAdminAccess", + "Terraform": "enable_admin_access", + "Required": false + }, + { + "ROS": null, + "Terraform": "enable_cross_desktop_access", + "Required": false + }, + { + "ROS": "EnableInternetAccess", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "mfa_enabled", + "Required": false + }, + { + "ROS": "NeedVerifyZeroDevice", + "Terraform": null, + "Required": false + }, + { + "ROS": "OfficeSiteName", + "Terraform": "office_site_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "sso_enabled", + "Required": false + }, + { + "ROS": "VerifyCode", + "Terraform": null, + "Required": false + }, + { + "ROS": "VpcType", + "Terraform": null, + "Required": false + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Attributes": [ + { + "ROS": "OfficeSiteId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ECD::UserDesktopGroupAddition", + "Terraform": null + }, + "ProductCode": "ecd", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "DesktopGroupId", + "Terraform": null, + "Required": true + }, + { + "ROS": "EndUserIds", + "Terraform": null, + "Required": true, + "Type": "list", + "Properties": {} + } + ], + "Attributes": [ + { + "ROS": "DesktopGroupId", + "Terraform": null + }, + { + "ROS": "EndUserIds", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::EDAS::Application", + "Terraform": "alicloud_edas_application" + }, + "ProductCode": "edas", + "Name": { + "zh": "EDAS集群应用", + "en": "EDAS Application in ECS Cluster" + }, + "Properties": [ + { + "ROS": "ApplicationName", + "Terraform": "application_name", + "Required": true + }, + { + "ROS": "BuildPackId", + "Terraform": "build_pack_id", + "Required": false + }, + { + "ROS": "ClusterId", + "Terraform": "cluster_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::EDAS::Cluster" + } + ] + }, + { + "ROS": "ComponentIds", + "Terraform": null, + "Required": false + }, + { + "ROS": "Deployment", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "AppEnv", + "Terraform": null, + "Required": false + }, + { + "ROS": "Batch", + "Terraform": null, + "Required": false + }, + { + "ROS": "BatchWaitTime", + "Terraform": null, + "Required": false + }, + { + "ROS": "Desc", + "Terraform": null, + "Required": false + }, + { + "ROS": "Gray", + "Terraform": null, + "Required": false + }, + { + "ROS": "GroupId", + "Terraform": null, + "Required": false + }, + { + "ROS": "PackageVersion", + "Terraform": null, + "Required": true + }, + { + "ROS": "ReleaseType", + "Terraform": null, + "Required": false + }, + { + "ROS": "TrafficControlStrategy", + "Terraform": null, + "Required": false + }, + { + "ROS": "WarUrl", + "Terraform": null, + "Required": true + } + ] + }, + { + "ROS": "Description", + "Terraform": "descriotion", + "Required": false + }, + { + "ROS": "EcuInfo", + "Terraform": "ecu_info", + "Required": false + }, + { + "ROS": null, + "Terraform": "group_id", + "Required": false + }, + { + "ROS": "HealthCheckURL", + "Terraform": "health_check_url", + "Required": false + }, + { + "ROS": "LogicalRegionId", + "Terraform": "logical_region_id", + "Required": false + }, + { + "ROS": "PackageType", + "Terraform": "package_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "package_version", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "war_url", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "AppId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "Port", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::EDAS::Cluster", + "Terraform": "alicloud_edas_cluster" + }, + "ProductCode": "edas", + "Name": { + "zh": "EDAS集群", + "en": "Cluster in EDAS" + }, + "Properties": [ + { + "ROS": "ClusterName", + "Terraform": "cluster_name", + "Required": true + }, + { + "ROS": "ClusterType", + "Terraform": "cluster_type", + "Required": true + }, + { + "ROS": "LogicalRegionId", + "Terraform": "logical_region_id", + "Required": false + }, + { + "ROS": "NetworkMode", + "Terraform": "network_mode", + "Required": true + }, + { + "ROS": "OversoldFactor", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ], + "Attributes": [ + { + "ROS": "ClusterName", + "Terraform": null + }, + { + "ROS": "ClusterType", + "Terraform": null + }, + { + "ROS": "IaasProvider", + "Terraform": null + }, + { + "ROS": "ClusterId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::EDAS::ClusterMember", + "Terraform": null + }, + "ProductCode": "edas", + "Name": { + "zh": "EDAS集群CS实例", + "en": "Add ECS Instances to Cluster in EDAS" + }, + "Properties": [ + { + "ROS": "ClusterId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::EDAS::Cluster" + } + ] + }, + { + "ROS": "InstanceIds", + "Terraform": null, + "Required": true, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "Password", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "ClusterId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::EDAS::Cluster" + } + ] + }, + { + "ROS": "ClusterMemberIds", + "Terraform": null + }, + { + "ROS": "EcuIds", + "Terraform": null + }, + { + "ROS": "InstanceIds", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::EDAS::DeployGroup", + "Terraform": "alicloud_edas_deploy_group" + }, + "ProductCode": "edas", + "Name": { + "zh": "EDAS分组", + "en": "EDAS Group" + }, + "Properties": [ + { + "ROS": "AppId", + "Terraform": "app_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::EDAS::Application" + } + ] + }, + { + "ROS": "GroupName", + "Terraform": "group_name", + "Required": true + }, + { + "ROS": null, + "Terraform": "group_type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "AppId", + "Terraform": null + }, + { + "ROS": "GroupName", + "Terraform": null + }, + { + "ROS": "Id", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::EDAS::K8sApplication", + "Terraform": "alicloud_edas_k8s_application" + }, + "ProductCode": "edas", + "Name": { + "zh": "EDAS Kubernetes集群应用", + "en": "EDAS Application in ACK Cluster" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "application_descriotion", + "Required": false + }, + { + "ROS": "ApplicationDescription", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "application_name", + "Required": false + }, + { + "ROS": "AppName", + "Terraform": null, + "Required": true + }, + { + "ROS": "ClusterId", + "Terraform": "cluster_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::EDAS::K8sApplication" + } + ] + }, + { + "ROS": "Command", + "Terraform": "command", + "Required": false + }, + { + "ROS": "CommandArgs", + "Terraform": "command_args", + "Required": false + }, + { + "ROS": "DeployAcrossNodes", + "Terraform": null, + "Required": false + }, + { + "ROS": "DeployAcrossZones", + "Terraform": null, + "Required": false + }, + { + "ROS": "EdasContainerVersion", + "Terraform": "edas_container_version", + "Required": false + }, + { + "ROS": "EnableAhas", + "Terraform": null, + "Required": false + }, + { + "ROS": "Envs", + "Terraform": "envs", + "Required": false + }, + { + "ROS": "ImageUrl", + "Terraform": "image_url", + "Required": false + }, + { + "ROS": "InternetSlbId", + "Terraform": null, + "Required": false + }, + { + "ROS": "InternetSlbPort", + "Terraform": null, + "Required": false + }, + { + "ROS": "InternetSlbProtocol", + "Terraform": null, + "Required": false + }, + { + "ROS": "InternetTargetPort", + "Terraform": null, + "Required": false + }, + { + "ROS": "IntranetSlbId", + "Terraform": null, + "Required": false + }, + { + "ROS": "IntranetSlbPort", + "Terraform": null, + "Required": false + }, + { + "ROS": "IntranetSlbProtocol", + "Terraform": null, + "Required": false + }, + { + "ROS": "IntranetTargetPort", + "Terraform": null, + "Required": false + }, + { + "ROS": "IsMultilingualApp", + "Terraform": null, + "Required": false + }, + { + "ROS": "JavaStartUpConfig", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "ConcGCThreads", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Original", + "Terraform": null, + "Required": false + }, + { + "ROS": "Startup", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "CustomParams", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Original", + "Terraform": null, + "Required": false + }, + { + "ROS": "Startup", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "G1HeapRegionSize", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Original", + "Terraform": null, + "Required": false + }, + { + "ROS": "Startup", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "GCLogFilePath", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Original", + "Terraform": null, + "Required": false + }, + { + "ROS": "Startup", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "GCLogFileSize", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Original", + "Terraform": null, + "Required": false + }, + { + "ROS": "Startup", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "HeapDumpOnOutOfMemoryError", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Original", + "Terraform": null, + "Required": false + }, + { + "ROS": "Startup", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "HeapDumpPath", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Original", + "Terraform": null, + "Required": false + }, + { + "ROS": "Startup", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "InitialHeapSize", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Original", + "Terraform": null, + "Required": false + }, + { + "ROS": "Startup", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "MaxDirectMemorySize", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Original", + "Terraform": null, + "Required": false + }, + { + "ROS": "Startup", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "MaxHeapSize", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Original", + "Terraform": null, + "Required": false + }, + { + "ROS": "Startup", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "MaxNewSize", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Original", + "Terraform": null, + "Required": false + }, + { + "ROS": "Startup", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "MaxPermSize", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Original", + "Terraform": null, + "Required": false + }, + { + "ROS": "Startup", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "NacosUseCloudNamespaceParsing", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Original", + "Terraform": null, + "Required": false + }, + { + "ROS": "Startup", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "NacosUseEndpointParsingRule", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Original", + "Terraform": null, + "Required": false + }, + { + "ROS": "Startup", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "NewRatio", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Original", + "Terraform": null, + "Required": false + }, + { + "ROS": "Startup", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "NewSize", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Original", + "Terraform": null, + "Required": false + }, + { + "ROS": "Startup", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "OldGarbageCollector", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Original", + "Terraform": null, + "Required": false + }, + { + "ROS": "Startup", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "ParallelGCThreads", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Original", + "Terraform": null, + "Required": false + }, + { + "ROS": "Startup", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "PermSize", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Original", + "Terraform": null, + "Required": false + }, + { + "ROS": "Startup", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "PrintGC", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Original", + "Terraform": null, + "Required": false + }, + { + "ROS": "Startup", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "PrintGCDateStamps", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Original", + "Terraform": null, + "Required": false + }, + { + "ROS": "Startup", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "SurvivorRatio", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Original", + "Terraform": null, + "Required": false + }, + { + "ROS": "Startup", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "ThreadStackSize", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Original", + "Terraform": null, + "Required": false + }, + { + "ROS": "Startup", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "UseGCLogFileRotation", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Original", + "Terraform": null, + "Required": false + }, + { + "ROS": "Startup", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "YoungGarbageCollector", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Original", + "Terraform": null, + "Required": false + }, + { + "ROS": "Startup", + "Terraform": null, + "Required": false + } + ] + } + ] + }, + { + "ROS": "JDK", + "Terraform": "jdk", + "Required": false + }, + { + "ROS": "LimitCpu", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "limit_m_cpu", + "Required": false + }, + { + "ROS": "LimitMem", + "Terraform": "limit_mem", + "Required": false + }, + { + "ROS": "Liveness", + "Terraform": "liveness", + "Required": false + }, + { + "ROS": "LocalVolume", + "Terraform": "local_volume", + "Required": false + }, + { + "ROS": "LogicalRegionId", + "Terraform": "logical_region_id", + "Required": false + }, + { + "ROS": "MountDescs", + "Terraform": "mount_descs", + "Required": false + }, + { + "ROS": "Namespace", + "Terraform": "namespace", + "Required": false + }, + { + "ROS": "NasId", + "Terraform": "nas_id", + "Required": false + }, + { + "ROS": "PackageType", + "Terraform": "package_type", + "Required": false + }, + { + "ROS": "PackageUrl", + "Terraform": "package_url", + "Required": false + }, + { + "ROS": "PackageVersion", + "Terraform": "package_version", + "Required": false + }, + { + "ROS": "PostStart", + "Terraform": "post_start", + "Required": false + }, + { + "ROS": "PreStop", + "Terraform": "pre_stop", + "Required": false + }, + { + "ROS": "Readiness", + "Terraform": "readiness", + "Required": false + }, + { + "ROS": "Replicas", + "Terraform": "replicas", + "Required": false + }, + { + "ROS": "RepoId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CR::Repository" + } + ] + }, + { + "ROS": "RequestsCpu", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "requests_m_cpu", + "Required": false + }, + { + "ROS": "RequestsMem", + "Terraform": "requests_mem", + "Required": false + }, + { + "ROS": "RuntimeClassName", + "Terraform": null, + "Required": false + }, + { + "ROS": "SlsConfigs", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "LogDir", + "Terraform": null, + "Required": false + }, + { + "ROS": "Logstore", + "Terraform": null, + "Required": false + }, + { + "ROS": "Type", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "StorageType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Timeout", + "Terraform": null, + "Required": false + }, + { + "ROS": "UriEncoding", + "Terraform": null, + "Required": false + }, + { + "ROS": "UseBodyEncoding", + "Terraform": null, + "Required": false + }, + { + "ROS": "WebContainer", + "Terraform": "web_container", + "Required": false + }, + { + "ROS": "WebContainerConfig", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "ContextInputType", + "Terraform": null, + "Required": false + }, + { + "ROS": "ContextPath", + "Terraform": null, + "Required": false + }, + { + "ROS": "HttpPort", + "Terraform": null, + "Required": false + }, + { + "ROS": "MaxThreads", + "Terraform": null, + "Required": false + }, + { + "ROS": "ServerXml", + "Terraform": null, + "Required": false + }, + { + "ROS": "UriEncoding", + "Terraform": null, + "Required": false + }, + { + "ROS": "UseAdvancedServerXml", + "Terraform": null, + "Required": false + }, + { + "ROS": "UseBodyEncoding", + "Terraform": null, + "Required": false + }, + { + "ROS": "UseDefaultConfig", + "Terraform": null, + "Required": false + } + ] + } + ], + "Attributes": [ + { + "ROS": "AppName", + "Terraform": null + }, + { + "ROS": "ChangeOrderId", + "Terraform": null + }, + { + "ROS": "ClusterId", + "Terraform": null + }, + { + "ROS": "CsClusterId", + "Terraform": null + }, + { + "ROS": "AppId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::EDAS::K8sCluster", + "Terraform": "alicloud_edas_k8s_cluster" + }, + "ProductCode": "edas", + "Name": { + "zh": "EDAS K8s集群", + "en": "ACK Cluster in EDAS" + }, + "Properties": [ + { + "ROS": "CsClusterId", + "Terraform": "cs_cluster_id", + "Required": true + }, + { + "ROS": "EnableAsm", + "Terraform": null, + "Required": false + }, + { + "ROS": "NamespaceId", + "Terraform": "namespace_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "ClusterId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "cluster_import_status" + }, + { + "ROS": "ClusterName", + "Terraform": "cluster_name", + "Primary": true + }, + { + "ROS": "ClusterType", + "Terraform": "cluster_type" + }, + { + "ROS": "CsClusterId", + "Terraform": null + }, + { + "ROS": "NetworkMode", + "Terraform": "network_mode" + }, + { + "ROS": "NodeNum", + "Terraform": null + }, + { + "ROS": "SubNetCidr", + "Terraform": null + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VswitchId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::EDAS::K8sSlbBinding", + "Terraform": "alicloud_edas_k8s_slb_attachment" + }, + "ProductCode": "edas", + "Name": { + "zh": "EDAS应用绑定SLB实例", + "en": "Associate SLB Instance with EDAS Application" + }, + "Properties": [ + { + "ROS": "AppId", + "Terraform": "app_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::EDAS::Application" + } + ] + }, + { + "ROS": "ClusterId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::EDAS::Cluster" + } + ] + }, + { + "ROS": "LoadBalancerId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::SLB::LoadBalancer" + } + ] + }, + { + "ROS": "Scheduler", + "Terraform": null, + "Required": false + }, + { + "ROS": "ServicePortInfos", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "CertId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CAS::Certificate" + } + ] + }, + { + "ROS": "LoadBalancerProtocol", + "Terraform": null, + "Required": true + }, + { + "ROS": "Port", + "Terraform": null, + "Required": true + }, + { + "ROS": "TargetPort", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": null, + "Terraform": "slb_configs", + "Required": false + }, + { + "ROS": "Specification", + "Terraform": null, + "Required": false + }, + { + "ROS": "Type", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "Address", + "Terraform": null + }, + { + "ROS": "AppId", + "Terraform": null + }, + { + "ROS": "ChangeOrderId", + "Terraform": null, + "Primary": true + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "LoadBalancerId", + "Terraform": null + }, + { + "ROS": "LoadBalancerName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::EDAS::UserDefineRegion", + "Terraform": "alicloud_edas_namespace" + }, + "ProductCode": "edas", + "Name": { + "zh": "EDAS自定义命名空间", + "en": "Custom EDAS Namespace" + }, + "Properties": [ + { + "ROS": "DebugEnable", + "Terraform": "debug_enable", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "RegionTag", + "Terraform": "namespace_logical_id", + "Required": true + }, + { + "ROS": "RegionName", + "Terraform": "namespace_name", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "BelongRegion", + "Terraform": null + }, + { + "ROS": "DebugEnable", + "Terraform": null + }, + { + "ROS": "Id", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "RegionName", + "Terraform": null + }, + { + "ROS": "UserId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::EHPC::AutoScaleConfig", + "Terraform": null + }, + "ProductCode": "ehpc", + "Name": { + "zh": "EHPC自动伸缩配置", + "en": "E-HPC Automatic Scaling Settings" + }, + "Properties": [ + { + "ROS": "ClusterId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::EHPC::Cluster" + } + ] + }, + { + "ROS": "EnableAutoGrow", + "Terraform": null, + "Required": false + }, + { + "ROS": "EnableAutoShrink", + "Terraform": null, + "Required": false + }, + { + "ROS": "ExcludeNodes", + "Terraform": null, + "Required": false + }, + { + "ROS": "ExtraNodesGrowRatio", + "Terraform": null, + "Required": false + }, + { + "ROS": "GrowIntervalInMinutes", + "Terraform": null, + "Required": false + }, + { + "ROS": "GrowRatio", + "Terraform": null, + "Required": false + }, + { + "ROS": "GrowTimeoutInMinutes", + "Terraform": null, + "Required": false + }, + { + "ROS": "ImageId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::CustomImage" + } + ] + }, + { + "ROS": "MaxNodesInCluster", + "Terraform": null, + "Required": false + }, + { + "ROS": "Queues", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "DataDisks", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "DataDiskCategory", + "Terraform": null, + "Required": false + }, + { + "ROS": "DataDiskDeleteWithInstance", + "Terraform": null, + "Required": false + }, + { + "ROS": "DataDiskEncrypted", + "Terraform": null, + "Required": false + }, + { + "ROS": "DataDiskKMSKeyId", + "Terraform": null, + "Required": false + }, + { + "ROS": "DataDiskPerformanceLevel", + "Terraform": null, + "Required": false + }, + { + "ROS": "DataDiskSize", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "EnableAutoGrow", + "Terraform": null, + "Required": false + }, + { + "ROS": "EnableAutoShrink", + "Terraform": null, + "Required": false + }, + { + "ROS": "HostNamePrefix", + "Terraform": null, + "Required": false + }, + { + "ROS": "HostNameSuffix", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceType", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceTypes", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "InstanceType", + "Terraform": null, + "Required": true + }, + { + "ROS": "SpotPriceLimit", + "Terraform": null, + "Required": false + }, + { + "ROS": "SpotStrategy", + "Terraform": null, + "Required": false + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "ZoneId", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "MaxNodesInQueue", + "Terraform": null, + "Required": false + }, + { + "ROS": "MaxNodesPerCycle", + "Terraform": null, + "Required": false + }, + { + "ROS": "MinNodesInQueue", + "Terraform": null, + "Required": false + }, + { + "ROS": "MinNodesPerCycle", + "Terraform": null, + "Required": false + }, + { + "ROS": "QueueImageId", + "Terraform": null, + "Required": false + }, + { + "ROS": "QueueName", + "Terraform": null, + "Required": false + }, + { + "ROS": "SpotPriceLimit", + "Terraform": null, + "Required": false + }, + { + "ROS": "SpotStrategy", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskCategory", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskLevel", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskSize", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "ShrinkIdleTimes", + "Terraform": null, + "Required": false + }, + { + "ROS": "ShrinkIntervalInMinutes", + "Terraform": null, + "Required": false + }, + { + "ROS": "SpotPriceLimit", + "Terraform": null, + "Required": false + }, + { + "ROS": "SpotStrategy", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "ClusterId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::EHPC::Cluster", + "Terraform": "alicloud_ehpc_cluster" + }, + "ProductCode": "ehpc", + "Name": { + "zh": "EHPC集群", + "en": "E-HPC Cluster" + }, + "Properties": [ + { + "ROS": "AccountType", + "Terraform": "account_type", + "Required": false + }, + { + "ROS": "AdditionalVolumes", + "Terraform": "additional_volumes", + "Required": false, + "Properties": [ + { + "ROS": "JobQueue", + "Terraform": "job_queue", + "Required": false + }, + { + "ROS": "LocalDirectory", + "Terraform": "local_directory", + "Required": true + }, + { + "ROS": "Location", + "Terraform": "location", + "Required": false + }, + { + "ROS": "RemoteDirectory", + "Terraform": "remote_directory", + "Required": false + }, + { + "ROS": null, + "Terraform": "roles", + "Required": false + }, + { + "ROS": "VolumeId", + "Terraform": "volume_id", + "Required": true + }, + { + "ROS": null, + "Terraform": "volume_mount_option", + "Required": false + }, + { + "ROS": "VolumeMountpoint", + "Terraform": "volume_mountpoint", + "Required": true + }, + { + "ROS": "VolumeProtocol", + "Terraform": "volume_protocol", + "Required": false + }, + { + "ROS": "VolumeType", + "Terraform": "volume_type", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "Application", + "Terraform": "application", + "Required": false, + "Properties": [ + { + "ROS": "Tag", + "Terraform": "tag", + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "AutoRenew", + "Terraform": "auto_renew", + "Required": false + }, + { + "ROS": "AutoRenewPeriod", + "Terraform": "auto_renew_period", + "Required": false + }, + { + "ROS": "ClientVersion", + "Terraform": "client_version", + "Required": false + }, + { + "ROS": null, + "Terraform": "cluster_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "cluster_version", + "Required": false + }, + { + "ROS": null, + "Terraform": "compute_count", + "Required": false + }, + { + "ROS": "ComputeEnableHt", + "Terraform": "compute_enable_ht", + "Required": false + }, + { + "ROS": null, + "Terraform": "compute_instance_type", + "Required": false + }, + { + "ROS": "ComputeSpotPriceLimit", + "Terraform": "compute_spot_price_limit", + "Required": false + }, + { + "ROS": "ComputeSpotStrategy", + "Terraform": "compute_spot_strategy", + "Required": false + }, + { + "ROS": "DeployMode", + "Terraform": "deploy_mode", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "domain", + "Required": false + }, + { + "ROS": "EcsChargeType", + "Terraform": "ecs_charge_type", + "Required": false + }, + { + "ROS": "EcsOrderComputeCount", + "Terraform": null, + "Required": true + }, + { + "ROS": "EcsOrderComputeInstanceType", + "Terraform": null, + "Required": true + }, + { + "ROS": "EcsOrderLoginCount", + "Terraform": null, + "Required": true + }, + { + "ROS": "EcsOrderLoginInstanceType", + "Terraform": null, + "Required": true + }, + { + "ROS": "EcsOrderManagerCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "EcsOrderManagerInstanceType", + "Terraform": null, + "Required": true + }, + { + "ROS": "EhpcVersion", + "Terraform": "ehpc_version", + "Required": false + }, + { + "ROS": "HaEnable", + "Terraform": "ha_enable", + "Required": false + }, + { + "ROS": "ImageId", + "Terraform": "image_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::CustomImage" + } + ] + }, + { + "ROS": "ImageOwnerAlias", + "Terraform": "image_owner_alias", + "Required": false + }, + { + "ROS": "InputFileUrl", + "Terraform": "input_file_url", + "Required": false + }, + { + "ROS": "IsComputeEss", + "Terraform": "is_compute_ess", + "Required": false + }, + { + "ROS": "JobQueue", + "Terraform": "job_queue", + "Required": false + }, + { + "ROS": "KeyPairName", + "Terraform": "key_pair_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "login_count", + "Required": false + }, + { + "ROS": null, + "Terraform": "login_instance_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "manager_count", + "Required": false + }, + { + "ROS": null, + "Terraform": "manager_instance_type", + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "NetworkInterfaceTrafficMode", + "Terraform": null, + "Required": false + }, + { + "ROS": "OsTag", + "Terraform": "os_tag", + "Required": true + }, + { + "ROS": "Password", + "Terraform": "password", + "Required": false + }, + { + "ROS": "Period", + "Terraform": "period", + "Required": false + }, + { + "ROS": "PeriodUnit", + "Terraform": "period_unit", + "Required": false + }, + { + "ROS": null, + "Terraform": "plugin", + "Required": false + }, + { + "ROS": "PostInstallScript", + "Terraform": "post_install_script", + "Required": false, + "Properties": [ + { + "ROS": "Args", + "Terraform": "args", + "Required": false + }, + { + "ROS": "Url", + "Terraform": "url", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "RamNodeTypes", + "Terraform": "ram_node_types", + "Required": false + }, + { + "ROS": "RamRoleName", + "Terraform": "ram_role_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "release_instance", + "Required": false + }, + { + "ROS": "RemoteDirectory", + "Terraform": "remote_directory", + "Required": false + }, + { + "ROS": "RemoteVisEnable", + "Terraform": "remote_vis_enable", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "SccClusterId", + "Terraform": "scc_cluster_id", + "Required": false + }, + { + "ROS": "SchedulerType", + "Terraform": "scheduler_type", + "Required": false + }, + { + "ROS": "SecurityGroupId", + "Terraform": "security_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "SecurityGroupName", + "Terraform": "security_group_name", + "Required": false + }, + { + "ROS": "SystemDiskLevel", + "Terraform": "system_disk_level", + "Required": false + }, + { + "ROS": "SystemDiskSize", + "Terraform": "system_disk_size", + "Required": false + }, + { + "ROS": "SystemDiskType", + "Terraform": "system_disk_type", + "Required": false + }, + { + "ROS": "VolumeId", + "Terraform": "volume_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "volume_mount_option", + "Required": false + }, + { + "ROS": "VolumeMountpoint", + "Terraform": "volume_mountpoint", + "Required": false + }, + { + "ROS": "VolumeProtocol", + "Terraform": "volume_protocol", + "Required": false + }, + { + "ROS": "VolumeType", + "Terraform": "volume_type", + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": null, + "Terraform": "without_agent", + "Required": false + }, + { + "ROS": "WithoutElasticIp", + "Terraform": "without_elastic_ip", + "Required": false + }, + { + "ROS": "ZoneId", + "Terraform": "zone_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "EcsInfo", + "Terraform": null + }, + { + "ROS": "ClusterId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "Name", + "Terraform": null + }, + { + "ROS": "SecurityGroupId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::EHPC::ClusterV2", + "Terraform": null + }, + "ProductCode": "ehpc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "AdditionalPackages", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "Version", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "Addons", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "ResourcesSpec", + "Terraform": null, + "Required": false + }, + { + "ROS": "ServicesSpec", + "Terraform": null, + "Required": false + }, + { + "ROS": "Version", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "ClientVersion", + "Terraform": null, + "Required": false + }, + { + "ROS": "ClusterCategory", + "Terraform": null, + "Required": false + }, + { + "ROS": "ClusterCredentials", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "KeyPairName", + "Terraform": null, + "Required": false + }, + { + "ROS": "Password", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "ClusterCustomConfiguration", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Args", + "Terraform": null, + "Required": false + }, + { + "ROS": "Script", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "ClusterDescription", + "Terraform": null, + "Required": false + }, + { + "ROS": "ClusterMode", + "Terraform": null, + "Required": false + }, + { + "ROS": "ClusterName", + "Terraform": null, + "Required": true + }, + { + "ROS": "DeletionProtection", + "Terraform": null, + "Required": false + }, + { + "ROS": "IsEnterpriseSecurityGroup", + "Terraform": null, + "Required": false + }, + { + "ROS": "Manager", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "DirectoryService", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Type", + "Terraform": null, + "Required": false + }, + { + "ROS": "Version", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "DNS", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Type", + "Terraform": null, + "Required": false + }, + { + "ROS": "Version", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "ManagerNode", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "AutoRenew", + "Terraform": null, + "Required": false + }, + { + "ROS": "AutoRenewPeriod", + "Terraform": null, + "Required": false + }, + { + "ROS": "DataDisks", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Category", + "Terraform": null, + "Required": true + }, + { + "ROS": "DeleteWithInstance", + "Terraform": null, + "Required": false + }, + { + "ROS": "Level", + "Terraform": null, + "Required": false + }, + { + "ROS": "MountDir", + "Terraform": null, + "Required": false + }, + { + "ROS": "Size", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "EnableHT", + "Terraform": null, + "Required": false + }, + { + "ROS": "ImageId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::CustomImage" + } + ] + }, + { + "ROS": "InstanceChargeType", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceType", + "Terraform": null, + "Required": true + }, + { + "ROS": "Period", + "Terraform": null, + "Required": false + }, + { + "ROS": "PeriodUnit", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDisk", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "Category", + "Terraform": null, + "Required": true + }, + { + "ROS": "Level", + "Terraform": null, + "Required": false + }, + { + "ROS": "Size", + "Terraform": null, + "Required": true + } + ] + } + ] + }, + { + "ROS": "Scheduler", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Type", + "Terraform": null, + "Required": false + }, + { + "ROS": "Version", + "Terraform": null, + "Required": false + } + ] + } + ] + }, + { + "ROS": "MaxCoreCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "MaxCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "Queues", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "AllocationStrategy", + "Terraform": null, + "Required": false + }, + { + "ROS": "ComputeNodes", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "DataDisks", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Category", + "Terraform": null, + "Required": true + }, + { + "ROS": "DeleteWithInstance", + "Terraform": null, + "Required": false + }, + { + "ROS": "Level", + "Terraform": null, + "Required": false + }, + { + "ROS": "MountDir", + "Terraform": null, + "Required": false + }, + { + "ROS": "Size", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "Duration", + "Terraform": null, + "Required": false + }, + { + "ROS": "EnableHT", + "Terraform": null, + "Required": false + }, + { + "ROS": "ImageId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::CustomImage" + } + ] + }, + { + "ROS": "InstanceType", + "Terraform": null, + "Required": true + }, + { + "ROS": "SpotPriceLimit", + "Terraform": null, + "Required": false + }, + { + "ROS": "SpotStrategy", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDisk", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "Category", + "Terraform": null, + "Required": true + }, + { + "ROS": "Level", + "Terraform": null, + "Required": false + }, + { + "ROS": "Size", + "Terraform": null, + "Required": true + } + ] + } + ], + "Type": "list" + }, + { + "ROS": "EnableScaleIn", + "Terraform": null, + "Required": false + }, + { + "ROS": "EnableScaleOut", + "Terraform": null, + "Required": false + }, + { + "ROS": "HostnamePrefix", + "Terraform": null, + "Required": false + }, + { + "ROS": "HostnameSuffix", + "Terraform": null, + "Required": false + }, + { + "ROS": "InitialCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "InterConnect", + "Terraform": null, + "Required": false + }, + { + "ROS": "KeepAliveNodes", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "MaxCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "MaxCountPerCycle", + "Terraform": null, + "Required": false + }, + { + "ROS": "MinCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "QueueName", + "Terraform": null, + "Required": true + }, + { + "ROS": "RamRole", + "Terraform": null, + "Required": false + }, + { + "ROS": "VSwitchIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + } + ], + "Type": "list" + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "SecurityGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "SharedStorages", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "FileSystemId", + "Terraform": null, + "Required": true + }, + { + "ROS": "MountDirectory", + "Terraform": null, + "Required": false + }, + { + "ROS": "MountOptions", + "Terraform": null, + "Required": false + }, + { + "ROS": "MountTargetDomain", + "Terraform": null, + "Required": true + }, + { + "ROS": "NASDirectory", + "Terraform": null, + "Required": false + }, + { + "ROS": "ProtocolType", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "VpcId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Attributes": [ + { + "ROS": "ClusterId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::EHPC::Users", + "Terraform": null + }, + "ProductCode": "ehpc", + "Name": { + "zh": "EHPC Users", + "en": "E-HPC Users" + }, + "Properties": [ + { + "ROS": "ClusterId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::EHPC::Cluster" + }, + { + "ResourceType": "ROS/ALIYUN::EHPC::ClusterV2" + } + ] + }, + { + "ROS": "Users", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "Group", + "Terraform": null, + "Required": true + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "Password", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::EMR::Cluster", + "Terraform": null + }, + "ProductCode": "emapreduce", + "Name": { + "zh": "E-MapReduce集群旧版", + "en": "EMR Cluster (Old)" + }, + "Properties": [ + { + "ROS": "AuthorizeContent", + "Terraform": null, + "Required": false + }, + { + "ROS": "AutoRenew", + "Terraform": null, + "Required": false + }, + { + "ROS": "BootstrapAction", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Arg", + "Terraform": null, + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": false + }, + { + "ROS": "Path", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "ChargeType", + "Terraform": null, + "Required": true + }, + { + "ROS": "ClickHouseConf", + "Terraform": null, + "Required": false + }, + { + "ROS": "ClusterType", + "Terraform": null, + "Required": true + }, + { + "ROS": "Config", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "ConfigKey", + "Terraform": null, + "Required": false + }, + { + "ROS": "ConfigValue", + "Terraform": null, + "Required": false + }, + { + "ROS": "Encrypt", + "Terraform": null, + "Required": false + }, + { + "ROS": "FileName", + "Terraform": null, + "Required": false + }, + { + "ROS": "Replace", + "Terraform": null, + "Required": false + }, + { + "ROS": "ServiceName", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "Configurations", + "Terraform": null, + "Required": false + }, + { + "ROS": "DepositType", + "Terraform": null, + "Required": false + }, + { + "ROS": "EasEnable", + "Terraform": null, + "Required": false + }, + { + "ROS": "EmrVer", + "Terraform": null, + "Required": true + }, + { + "ROS": "HighAvailabilityEnable", + "Terraform": null, + "Required": false + }, + { + "ROS": "HostGroup", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "AutoRenew", + "Terraform": null, + "Required": false + }, + { + "ROS": "ChargeType", + "Terraform": null, + "Required": true + }, + { + "ROS": "ClusterId", + "Terraform": null, + "Required": false + }, + { + "ROS": "Comment", + "Terraform": null, + "Required": false + }, + { + "ROS": "CreateType", + "Terraform": null, + "Required": false + }, + { + "ROS": "DiskCapacity", + "Terraform": null, + "Required": true + }, + { + "ROS": "DiskCount", + "Terraform": null, + "Required": true + }, + { + "ROS": "DiskType", + "Terraform": null, + "Required": true + }, + { + "ROS": "GpuDriver", + "Terraform": null, + "Required": false + }, + { + "ROS": "HostGroupId", + "Terraform": null, + "Required": false + }, + { + "ROS": "HostGroupName", + "Terraform": null, + "Required": false + }, + { + "ROS": "HostGroupType", + "Terraform": null, + "Required": true + }, + { + "ROS": "HostKeyPairName", + "Terraform": null, + "Required": false + }, + { + "ROS": "HostPassword", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceType", + "Terraform": null, + "Required": true + }, + { + "ROS": "NodeCount", + "Terraform": null, + "Required": true + }, + { + "ROS": "Period", + "Terraform": null, + "Required": false + }, + { + "ROS": "SysDiskCapacity", + "Terraform": null, + "Required": true + }, + { + "ROS": "SysDiskType", + "Terraform": null, + "Required": true + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Type": "list" + }, + { + "ROS": "InitCustomHiveMetaDB", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceGeneration", + "Terraform": null, + "Required": false + }, + { + "ROS": "IoOptimized", + "Terraform": null, + "Required": false + }, + { + "ROS": "IsOpenPublicIp", + "Terraform": null, + "Required": false + }, + { + "ROS": "KeyPairName", + "Terraform": null, + "Required": false + }, + { + "ROS": "LogPath", + "Terraform": null, + "Required": false + }, + { + "ROS": "MachineType", + "Terraform": null, + "Required": false + }, + { + "ROS": "MasterPwd", + "Terraform": null, + "Required": false + }, + { + "ROS": "MetaStoreConf", + "Terraform": null, + "Required": false + }, + { + "ROS": "MetaStoreType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "NetType", + "Terraform": null, + "Required": true + }, + { + "ROS": "OptionSoftWareList", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "Period", + "Terraform": null, + "Required": false + }, + { + "ROS": "RelatedClusterId", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "SecurityGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "SecurityGroupName", + "Terraform": null, + "Required": false + }, + { + "ROS": "SshEnable", + "Terraform": null, + "Required": false + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "UseCustomHiveMetaDB", + "Terraform": null, + "Required": false + }, + { + "ROS": "UseLocalMetaDb", + "Terraform": null, + "Required": true + }, + { + "ROS": "UserDefinedEmrEcsRole", + "Terraform": null, + "Required": false + }, + { + "ROS": "UserInfo", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Password", + "Terraform": null, + "Required": false + }, + { + "ROS": "UserId", + "Terraform": null, + "Required": false + }, + { + "ROS": "UserName", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "VpcId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "WhiteListType", + "Terraform": null, + "Required": false + }, + { + "ROS": "ZoneId", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": "ClusterId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "HostGroups", + "Terraform": null + }, + { + "ROS": "MasterNodeInnerIps", + "Terraform": null + }, + { + "ROS": "MasterNodePubIps", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::EMR::Cluster2", + "Terraform": "alicloud_emrv2_cluster" + }, + "ProductCode": "emapreduce", + "Name": { + "zh": "E-MapReduce集群", + "en": "EMR Cluster (New)" + }, + "Properties": [ + { + "ROS": "ApplicationConfigs", + "Terraform": "application_configs", + "Required": false, + "Properties": [ + { + "ROS": "ApplicationName", + "Terraform": "application_name", + "Required": true + }, + { + "ROS": null, + "Terraform": "config_description", + "Required": false + }, + { + "ROS": "ConfigFileName", + "Terraform": "config_file_name", + "Required": false + }, + { + "ROS": "ConfigItemKey", + "Terraform": "config_item_key", + "Required": false + }, + { + "ROS": "ConfigItemValue", + "Terraform": "config_item_value", + "Required": false + }, + { + "ROS": "ConfigScope", + "Terraform": "config_scope", + "Required": false + }, + { + "ROS": "NodeGroupId", + "Terraform": "node_group_id", + "Required": false + }, + { + "ROS": "NodeGroupName", + "Terraform": "node_group_name", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "Applications", + "Terraform": "applications", + "Required": true + }, + { + "ROS": "BootstrapScripts", + "Terraform": "bootstrap_scripts", + "Required": false, + "Properties": [ + { + "ROS": "ExecutionFailStrategy", + "Terraform": "execution_fail_strategy", + "Required": false + }, + { + "ROS": "ExecutionMoment", + "Terraform": "execution_moment", + "Required": false + }, + { + "ROS": "NodeSelector", + "Terraform": "node_selector", + "Required": true + }, + { + "ROS": "ScriptArgs", + "Terraform": "script_args", + "Required": false + }, + { + "ROS": "ScriptName", + "Terraform": "script_name", + "Required": true + }, + { + "ROS": "ScriptPath", + "Terraform": "script_path", + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "ClusterName", + "Terraform": "cluster_name", + "Required": true + }, + { + "ROS": "ClusterType", + "Terraform": "cluster_type", + "Required": true + }, + { + "ROS": "DeployMode", + "Terraform": "deploy_mode", + "Required": false + }, + { + "ROS": null, + "Terraform": "log_collect_strategy", + "Required": false + }, + { + "ROS": "NodeAttributes", + "Terraform": "node_attributes", + "Required": true + }, + { + "ROS": "NodeGroups", + "Terraform": "node_groups", + "Required": true, + "Properties": [ + { + "ROS": "AdditionalSecurityGroupIds", + "Terraform": "additional_security_group_ids", + "Required": false + }, + { + "ROS": null, + "Terraform": "auto_scaling_policy", + "Required": false + }, + { + "ROS": "CostOptimizedConfig", + "Terraform": "cost_optimized_config", + "Required": false + }, + { + "ROS": "DataDisks", + "Terraform": "data_disks", + "Required": false, + "Properties": [ + { + "ROS": "Category", + "Terraform": "category", + "Required": true + }, + { + "ROS": "Count", + "Terraform": "count", + "Required": false + }, + { + "ROS": "PerformanceLevel", + "Terraform": "performance_level", + "Required": false + }, + { + "ROS": "Size", + "Terraform": "size", + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "DeploymentSetStrategy", + "Terraform": "deployment_set_strategy", + "Required": false + }, + { + "ROS": "GracefulShutdown", + "Terraform": "graceful_shutdown", + "Required": false + }, + { + "ROS": "InstanceTypes", + "Terraform": "instance_types", + "Required": true + }, + { + "ROS": "NodeCount", + "Terraform": "node_count", + "Required": false + }, + { + "ROS": "NodeGroupName", + "Terraform": "node_group_name", + "Required": false + }, + { + "ROS": "NodeGroupType", + "Terraform": "node_group_type", + "Required": true + }, + { + "ROS": "NodeResizeStrategy", + "Terraform": "node_resize_strategy", + "Required": false + }, + { + "ROS": null, + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": "SpotBidPrices", + "Terraform": "spot_bid_prices", + "Required": false, + "Properties": [ + { + "ROS": "BidPrice", + "Terraform": "bid_price", + "Required": false + }, + { + "ROS": "InstanceType", + "Terraform": "instance_type", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "SpotInstanceRemedy", + "Terraform": "spot_instance_remedy", + "Required": false + }, + { + "ROS": null, + "Terraform": "subscription_config", + "Required": false + }, + { + "ROS": "SystemDisk", + "Terraform": "system_disk", + "Required": false + }, + { + "ROS": null, + "Terraform": "vswitch_ids", + "Required": false + }, + { + "ROS": "WithPublicIp", + "Terraform": "with_public_ip", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "PaymentType", + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": "ReleaseVersion", + "Terraform": "release_version", + "Required": true + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "SecurityMode", + "Terraform": "security_mode", + "Required": false + }, + { + "ROS": "SubscriptionConfig", + "Terraform": "subscription_config", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "ApplicationLinks", + "Terraform": null + }, + { + "ROS": "ClusterId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::EMR::ClusterServiceConfigs", + "Terraform": null + }, + "ProductCode": "emapreduce", + "Name": { + "zh": "E-MapReduce集群服务配置信息", + "en": "EMR Cluster Service Configurations" + }, + "Properties": [ + { + "ROS": "ClusterId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::EMR::Cluster" + }, + { + "ResourceType": "ROS/ALIYUN::EMR::Cluster2" + } + ] + }, + { + "ROS": "ServiceConfigs", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "Comment", + "Terraform": null, + "Required": false + }, + { + "ROS": "ConfigParams", + "Terraform": null, + "Required": true + }, + { + "ROS": "ConfigType", + "Terraform": null, + "Required": false + }, + { + "ROS": "CustomConfigParams", + "Terraform": null, + "Required": false + }, + { + "ROS": "GatewayClusterIdList", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "GroupId", + "Terraform": null, + "Required": false + }, + { + "ROS": "HostInstanceId", + "Terraform": null, + "Required": false + }, + { + "ROS": "RefreshHostConfig", + "Terraform": null, + "Required": false + }, + { + "ROS": "ServiceName", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "ClusterId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::EMR::FlowProject", + "Terraform": null + }, + "ProductCode": "emapreduce", + "Name": { + "zh": "E-MapReduce数据开发项目", + "en": "EMR Data Development Project" + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": null, + "Required": true + }, + { + "ROS": "FlowProjectName", + "Terraform": null, + "Required": true + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + } + ], + "Attributes": [ + { + "ROS": "CreateTime", + "Terraform": null + }, + { + "ROS": "Description", + "Terraform": null + }, + { + "ROS": "FlowProjectId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "FlowProjectName", + "Terraform": null + }, + { + "ROS": "GmtModified", + "Terraform": null + }, + { + "ROS": "UserId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ENS::Disk", + "Terraform": "alicloud_ens_disk" + }, + "ProductCode": "ens", + "Name": { + "zh": "ENS Disk", + "en": "ENS Disk" + }, + "Properties": [ + { + "ROS": "Category", + "Terraform": "category", + "Required": true + }, + { + "ROS": "DiskName", + "Terraform": "disk_name", + "Required": false + }, + { + "ROS": "Encrypted", + "Terraform": "encrypted", + "Required": false + }, + { + "ROS": "EnsRegionId", + "Terraform": "ens_region_id", + "Required": true + }, + { + "ROS": "InstanceChargeType", + "Terraform": null, + "Required": true + }, + { + "ROS": "KMSKeyId", + "Terraform": "kms_key_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::KMS::Key" + } + ] + }, + { + "ROS": null, + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": "Size", + "Terraform": "size", + "Required": true + }, + { + "ROS": "SnapshotId", + "Terraform": "snapshot_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ENS::Snapshot" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "DiskId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ENS::DiskInstanceAttachment", + "Terraform": "alicloud_ens_disk_instance_attachment" + }, + "MainResourceType": { + "ResourceType": "ROS/ALIYUN::ENS::Disk", + "RefProperty": "ROS/DiskId" + }, + "ProductCode": "ens", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "DeleteWithInstance", + "Terraform": "delete_with_instance", + "Required": false + }, + { + "ROS": "DiskId", + "Terraform": "disk_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ENS::Disk" + } + ] + }, + { + "ROS": "InstanceId", + "Terraform": "instance_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ENS::Instance" + } + ] + } + ], + "Attributes": [ + { + "ROS": "DiskId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Disk" + } + ] + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "InstanceId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ENS::Image", + "Terraform": "alicloud_ens_image" + }, + "ProductCode": "ens", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "DeleteAfterImageUpload", + "Terraform": "delete_after_image_upload", + "Required": false + }, + { + "ROS": "ImageName", + "Terraform": "image_name", + "Required": true + }, + { + "ROS": "InstanceId", + "Terraform": "instance_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ENS::Instance" + } + ] + } + ], + "Attributes": [ + { + "ROS": "Architecture", + "Terraform": null + }, + { + "ROS": "ComputeType", + "Terraform": null + }, + { + "ROS": "CreateTime", + "Terraform": "create_time" + }, + { + "ROS": "ImageId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "ImageName", + "Terraform": null + }, + { + "ROS": "ImageOwnerAlias", + "Terraform": null + }, + { + "ROS": "ImageSize", + "Terraform": null + }, + { + "ROS": "InstanceId", + "Terraform": null + }, + { + "ROS": "OsVersion", + "Terraform": null + }, + { + "ROS": "Platform", + "Terraform": null + }, + { + "ROS": "SnapshotId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Snapshot" + } + ] + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ENS::Instance", + "Terraform": "alicloud_ens_instance" + }, + "ProductCode": "ens", + "Name": { + "zh": "ENS实例", + "en": "ENS Instance" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "amount", + "Required": false + }, + { + "ROS": null, + "Terraform": "auto_release_time", + "Required": false + }, + { + "ROS": "AutoRenew", + "Terraform": "auto_renew", + "Required": false + }, + { + "ROS": "AutoRenewPeriod", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "auto_use_coupon", + "Required": false + }, + { + "ROS": null, + "Terraform": "billing_cycle", + "Required": false + }, + { + "ROS": null, + "Terraform": "carrier", + "Required": false + }, + { + "ROS": null, + "Terraform": "data_disk", + "Required": false + }, + { + "ROS": "DataDiskSize", + "Terraform": null, + "Required": true + }, + { + "ROS": "EnsRegionId", + "Terraform": "ens_region_id", + "Required": true + }, + { + "ROS": null, + "Terraform": "force_stop", + "Required": false + }, + { + "ROS": "HostName", + "Terraform": "host_name", + "Required": false + }, + { + "ROS": "ImageId", + "Terraform": "image_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ENS::Image" + } + ] + }, + { + "ROS": null, + "Terraform": "include_data_disks", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_charge_strategy", + "Required": false + }, + { + "ROS": "InstanceName", + "Terraform": "instance_name", + "Required": false + }, + { + "ROS": "InstanceType", + "Terraform": "instance_type", + "Required": true + }, + { + "ROS": "InternetChargeType", + "Terraform": "internet_charge_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "internet_max_bandwidth_out", + "Required": false + }, + { + "ROS": "IpType", + "Terraform": "ip_type", + "Required": false + }, + { + "ROS": "KeyPairName", + "Terraform": "key_pair_name", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ENS::KeyPair" + } + ] + }, + { + "ROS": null, + "Terraform": "net_district_code", + "Required": false + }, + { + "ROS": null, + "Terraform": "net_work_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ENS::Network" + } + ] + }, + { + "ROS": "Password", + "Terraform": "password", + "Required": false + }, + { + "ROS": null, + "Terraform": "password_inherit", + "Required": false + }, + { + "ROS": "PaymentType", + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": "Period", + "Terraform": "period", + "Required": true + }, + { + "ROS": null, + "Terraform": "period_unit", + "Required": false + }, + { + "ROS": "PrivateIpAddress", + "Terraform": "private_ip_address", + "Required": false + }, + { + "ROS": null, + "Terraform": "public_ip_identification", + "Required": false + }, + { + "ROS": "Quantity", + "Terraform": null, + "Required": true + }, + { + "ROS": null, + "Terraform": "schedule_area_level", + "Required": false + }, + { + "ROS": null, + "Terraform": "scheduling_price_strategy", + "Required": false + }, + { + "ROS": null, + "Terraform": "scheduling_strategy", + "Required": false + }, + { + "ROS": null, + "Terraform": "security_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "spot_strategy", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": null, + "Terraform": "system_disk", + "Required": false + }, + { + "ROS": "SystemDiskSize", + "Terraform": null, + "Required": true + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": "UniqueSuffix", + "Terraform": "unique_suffix", + "Required": false + }, + { + "ROS": "UserData", + "Terraform": "user_data", + "Required": false + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Attributes": [ + { + "ROS": "AutoRenew", + "Terraform": null + }, + { + "ROS": "AutoRenewPeriod", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "data_disk" + }, + { + "ROS": "DataDiskSize", + "Terraform": null + }, + { + "ROS": "EnsRegionId", + "Terraform": null + }, + { + "ROS": "HostName", + "Terraform": null + }, + { + "ROS": "InstanceId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "ImageId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::CustomImage" + } + ] + }, + { + "ROS": "InstanceName", + "Terraform": null + }, + { + "ROS": "InstanceType", + "Terraform": null + }, + { + "ROS": "InternetChargeType", + "Terraform": null + }, + { + "ROS": "IpType", + "Terraform": null + }, + { + "ROS": "KeyPairName", + "Terraform": null + }, + { + "ROS": "PaymentType", + "Terraform": null + }, + { + "ROS": "Period", + "Terraform": null + }, + { + "ROS": "PrivateIpAddress", + "Terraform": null + }, + { + "ROS": "PrivateIps", + "Terraform": null + }, + { + "ROS": "PublicIps", + "Terraform": null + }, + { + "ROS": "Quantity", + "Terraform": null + }, + { + "ROS": "SystemDiskSize", + "Terraform": null + }, + { + "ROS": "UniqueSuffix", + "Terraform": null + }, + { + "ROS": "UserData", + "Terraform": null + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ENS::InstanceSecurityGroupAttachment", + "Terraform": "alicloud_ens_instance_security_group_attachment" + }, + "MainResourceType": { + "ResourceType": "ROS/ALIYUN::ENS::SecurityGroup", + "RefProperty": "ROS/SecurityGroupId" + }, + "ProductCode": "ens", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "InstanceId", + "Terraform": "instance_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ENS::Instance" + } + ] + }, + { + "ROS": "SecurityGroupId", + "Terraform": "security_group_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "InstanceId", + "Terraform": null + }, + { + "ROS": "SecurityGroupId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ENS::KeyPair", + "Terraform": "alicloud_ens_key_pair" + }, + "ProductCode": "ens", + "Name": { + "zh": "ENS KeyPair", + "en": "ENS Key Pair" + }, + "Properties": [ + { + "ROS": "KeyPairName", + "Terraform": "key_pair_name", + "Required": true + }, + { + "ROS": "PublicKeyBody", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "version", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "KeyPairName", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "KeyPairFingerPrint", + "Terraform": null + }, + { + "ROS": "PrivateKeyBody", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ENS::Network", + "Terraform": "alicloud_ens_network" + }, + "ProductCode": "ens", + "Name": { + "zh": "ENS Network", + "en": "ENS Network" + }, + "Properties": [ + { + "ROS": "CidrBlock", + "Terraform": "cidr_block", + "Required": true + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "EnsRegionId", + "Terraform": "ens_region_id", + "Required": true + }, + { + "ROS": "NetworkName", + "Terraform": "network_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "NetworkId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ENS::NetworkAcl", + "Terraform": null + }, + "ProductCode": "ens", + "Name": { + "zh": "ENS NetworkAcl", + "en": "ENS Network ACL" + }, + "Properties": [ + { + "ROS": "AclEntries", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "CidrBlock", + "Terraform": null, + "Required": true + }, + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "Direction", + "Terraform": null, + "Required": true + }, + { + "ROS": "NetworkAclEntryName", + "Terraform": null, + "Required": false + }, + { + "ROS": "Policy", + "Terraform": null, + "Required": true + }, + { + "ROS": "PortRange", + "Terraform": null, + "Required": true + }, + { + "ROS": "Priority", + "Terraform": null, + "Required": true + }, + { + "ROS": "Protocol", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "NetworkAclName", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "NetworkAclId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ENS::NetworkAclAssociation", + "Terraform": null + }, + "MainResourceType": { + "ResourceType": "ROS/ALIYUN::ENS::NetworkAcl", + "RefProperty": "ROS/NetworkAclId" + }, + "ProductCode": "ens", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "NetworkAclId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ENS::NetworkAclAssociation" + } + ] + }, + { + "ROS": "NetworkIds", + "Terraform": null, + "Required": true, + "Properties": {}, + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "NetworkAclId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ENS::SecurityGroup", + "Terraform": "alicloud_ens_security_group" + }, + "ProductCode": "ens", + "Name": { + "zh": "ENS安全组", + "en": "ENS Security Group" + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "SecurityGroupEgress", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "DestCidrIp", + "Terraform": null, + "Required": false + }, + { + "ROS": "IpProtocol", + "Terraform": null, + "Required": true + }, + { + "ROS": "Policy", + "Terraform": null, + "Required": false + }, + { + "ROS": "PortRange", + "Terraform": null, + "Required": true + }, + { + "ROS": "Priority", + "Terraform": null, + "Required": false + }, + { + "ROS": "SourcePortRange", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "SecurityGroupIngress", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "IpProtocol", + "Terraform": null, + "Required": true + }, + { + "ROS": "Policy", + "Terraform": null, + "Required": false + }, + { + "ROS": "PortRange", + "Terraform": null, + "Required": true + }, + { + "ROS": "Priority", + "Terraform": null, + "Required": false + }, + { + "ROS": "SourceCidrIp", + "Terraform": null, + "Required": false + }, + { + "ROS": "SourcePortRange", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "SecurityGroupName", + "Terraform": "security_group_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "SecurityGroupId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ENS::Snapshot", + "Terraform": "alicloud_ens_snapshot" + }, + "ProductCode": "ens", + "Name": { + "zh": "ENS快照", + "en": "ENS Snapshot" + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "DiskId", + "Terraform": "disk_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ENS::Disk" + } + ] + }, + { + "ROS": "EnsRegionId", + "Terraform": "ens_region_id", + "Required": true + }, + { + "ROS": "SnapshotName", + "Terraform": "snapshot_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "SnapShotId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ENS::VSwitch", + "Terraform": "alicloud_ens_vswitch" + }, + "ProductCode": "ens", + "Name": { + "zh": "ENS交换机", + "en": "ENS VSwitch" + }, + "Properties": [ + { + "ROS": "CidrBlock", + "Terraform": "cidr_block", + "Required": true + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "EnsRegionId", + "Terraform": "ens_region_id", + "Required": true + }, + { + "ROS": "NetworkId", + "Terraform": "network_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ENS::Network" + } + ] + }, + { + "ROS": "VSwitchName", + "Terraform": "vswitch_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "VSwitchId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ESS::AlarmTask", + "Terraform": "alicloud_ess_alarm" + }, + "ProductCode": "ess", + "Name": { + "zh": "ESS报警任务", + "en": "Auto Scaling Event-triggered Task" + }, + "Properties": [ + { + "ROS": "AlarmAction", + "Terraform": "alarm_actions", + "Required": true + }, + { + "ROS": "GroupId", + "Terraform": "cloud_monitor_group_id", + "Required": false + }, + { + "ROS": "ComparisonOperator", + "Terraform": "comparison_operator", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "Dimensions", + "Terraform": "dimensions", + "Required": false + }, + { + "ROS": null, + "Terraform": "effective", + "Required": false + }, + { + "ROS": null, + "Terraform": "enable", + "Required": false + }, + { + "ROS": "EvaluationCount", + "Terraform": "evaluation_count", + "Required": false + }, + { + "ROS": null, + "Terraform": "expressions", + "Required": false + }, + { + "ROS": null, + "Terraform": "expressions_logic_operator", + "Required": false + }, + { + "ROS": "MetricName", + "Terraform": "metric_name", + "Required": true + }, + { + "ROS": "MetricType", + "Terraform": "metric_type", + "Required": false + }, + { + "ROS": "Name", + "Terraform": "name", + "Required": false + }, + { + "ROS": "Period", + "Terraform": "period", + "Required": false + }, + { + "ROS": "ScalingGroupId", + "Terraform": "scaling_group_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ESS::ScalingGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "state", + "Required": false + }, + { + "ROS": "Statistics", + "Terraform": "statistics", + "Required": false + }, + { + "ROS": "Threshold", + "Terraform": "threshold", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "AlarmTaskId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ESS::AlarmTaskEnable", + "Terraform": null + }, + "ProductCode": "ess", + "Name": { + "zh": "启动ESS报警任务", + "en": "Enable Auto Scaling Event-triggered Task" + }, + "Properties": [ + { + "ROS": "AlarmTaskId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ESS::AlarmTask" + } + ] + }, + { + "ROS": "Enable", + "Terraform": null, + "Required": true + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ESS::EciScalingConfiguration", + "Terraform": "alicloud_ess_eci_scaling_configuration" + }, + "ProductCode": "ess", + "Name": { + "zh": "ESS EciScalingConfiguration", + "en": "Elastic Container Instance Scaling Configuration" + }, + "Properties": [ + { + "ROS": "AcrRegistryInfos", + "Terraform": "acr_registry_infos", + "Required": false, + "Properties": [ + { + "ROS": "Domains", + "Terraform": "domains", + "Required": false + }, + { + "ROS": "InstanceId", + "Terraform": "instance_id", + "Required": true + }, + { + "ROS": "InstanceName", + "Terraform": "instance_name", + "Required": false + }, + { + "ROS": "RegionId", + "Terraform": "region_id", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": null, + "Terraform": "active", + "Required": false + }, + { + "ROS": "ActiveDeadlineSeconds", + "Terraform": "active_deadline_seconds", + "Required": false + }, + { + "ROS": "AutoCreateEip", + "Terraform": "auto_create_eip", + "Required": false + }, + { + "ROS": "AutoMatchImageCache", + "Terraform": "auto_match_image_cache", + "Required": false + }, + { + "ROS": "ContainerGroupName", + "Terraform": "container_group_name", + "Required": true + }, + { + "ROS": "Containers", + "Terraform": "containers", + "Required": false, + "Properties": [ + { + "ROS": "Args", + "Terraform": "args", + "Required": false + }, + { + "ROS": "Commands", + "Terraform": "commands", + "Required": false + }, + { + "ROS": "Cpu", + "Terraform": "cpu", + "Required": false + }, + { + "ROS": "EnvironmentVars", + "Terraform": "environment_vars", + "Required": false, + "Properties": [ + { + "ROS": null, + "Terraform": "field_ref_field_path", + "Required": false + }, + { + "ROS": "Key", + "Terraform": "key", + "Required": false + }, + { + "ROS": "Value", + "Terraform": "value", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "Gpu", + "Terraform": "gpu", + "Required": false + }, + { + "ROS": "Image", + "Terraform": "image", + "Required": true + }, + { + "ROS": "ImagePullPolicy", + "Terraform": "image_pull_policy", + "Required": false + }, + { + "ROS": null, + "Terraform": "lifecycle_pre_stop_handler_execs", + "Required": false + }, + { + "ROS": "LivenessProbeExecCommands", + "Terraform": "liveness_probe_exec_commands", + "Required": false + }, + { + "ROS": "LivenessProbeFailureThreshold", + "Terraform": "liveness_probe_failure_threshold", + "Required": false + }, + { + "ROS": "LivenessProbeHttpGetPath", + "Terraform": "liveness_probe_http_get_path", + "Required": false + }, + { + "ROS": "LivenessProbeHttpGetPort", + "Terraform": "liveness_probe_http_get_port", + "Required": false + }, + { + "ROS": "LivenessProbeHttpGetScheme", + "Terraform": "liveness_probe_http_get_scheme", + "Required": false + }, + { + "ROS": "LivenessProbeInitialDelaySeconds", + "Terraform": "liveness_probe_initial_delay_seconds", + "Required": false + }, + { + "ROS": "LivenessProbePeriodSeconds", + "Terraform": "liveness_probe_period_seconds", + "Required": false + }, + { + "ROS": "LivenessProbeSuccessThreshold", + "Terraform": "liveness_probe_success_threshold", + "Required": false + }, + { + "ROS": "LivenessProbeTcpSocketPort", + "Terraform": "liveness_probe_tcp_socket_port", + "Required": false + }, + { + "ROS": "LivenessProbeTimeoutSeconds", + "Terraform": "liveness_probe_timeout_seconds", + "Required": false + }, + { + "ROS": "Memory", + "Terraform": "memory", + "Required": false + }, + { + "ROS": "Name", + "Terraform": "name", + "Required": true + }, + { + "ROS": "Ports", + "Terraform": "ports", + "Required": false, + "Properties": [ + { + "ROS": "Port", + "Terraform": "port", + "Required": true + }, + { + "ROS": "Protocol", + "Terraform": "protocol", + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "ReadinessProbeExecCommands", + "Terraform": "readiness_probe_exec_commands", + "Required": false + }, + { + "ROS": "ReadinessProbeFailureThreshold", + "Terraform": "readiness_probe_failure_threshold", + "Required": false + }, + { + "ROS": "ReadinessProbeHttpGetPath", + "Terraform": "readiness_probe_http_get_path", + "Required": false + }, + { + "ROS": "ReadinessProbeHttpGetPort", + "Terraform": "readiness_probe_http_get_port", + "Required": false + }, + { + "ROS": "ReadinessProbeHttpGetScheme", + "Terraform": "readiness_probe_http_get_scheme", + "Required": false + }, + { + "ROS": "ReadinessProbeInitialDelaySeconds", + "Terraform": "readiness_probe_initial_delay_seconds", + "Required": false + }, + { + "ROS": "ReadinessProbePeriodSeconds", + "Terraform": "readiness_probe_period_seconds", + "Required": false + }, + { + "ROS": "ReadinessProbeSuccessThreshold", + "Terraform": "readiness_probe_success_threshold", + "Required": false + }, + { + "ROS": "ReadinessProbeTcpSocketPort", + "Terraform": "readiness_probe_tcp_socket_port", + "Required": false + }, + { + "ROS": "ReadinessProbeTimeoutSeconds", + "Terraform": "readiness_probe_timeout_seconds", + "Required": false + }, + { + "ROS": null, + "Terraform": "security_context_capability_adds", + "Required": false + }, + { + "ROS": null, + "Terraform": "security_context_read_only_root_file_system", + "Required": false + }, + { + "ROS": "SecurityContextRunAsUser", + "Terraform": "security_context_run_as_user", + "Required": false + }, + { + "ROS": "Stdin", + "Terraform": "stdin", + "Required": false + }, + { + "ROS": "Tty", + "Terraform": "tty", + "Required": false + }, + { + "ROS": "VolumeMounts", + "Terraform": "volume_mounts", + "Required": false, + "Properties": [ + { + "ROS": "MountPath", + "Terraform": "mount_path", + "Required": false + }, + { + "ROS": "MountPropagation", + "Terraform": "mount_propagation", + "Required": false + }, + { + "ROS": "Name", + "Terraform": "name", + "Required": false + }, + { + "ROS": "ReadOnly", + "Terraform": "read_only", + "Required": false + }, + { + "ROS": "SubPath", + "Terraform": "sub_path", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "WorkingDir", + "Terraform": "working_dir", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "CostOptimization", + "Terraform": "cost_optimization", + "Required": false + }, + { + "ROS": "Cpu", + "Terraform": "cpu", + "Required": false + }, + { + "ROS": "CpuOptionsCore", + "Terraform": "cpu_options_core", + "Required": false + }, + { + "ROS": "CpuOptionsThreadsPerCore", + "Terraform": "cpu_options_threads_per_core", + "Required": false + }, + { + "ROS": "DataCacheBucket", + "Terraform": null, + "Required": false + }, + { + "ROS": "DataCacheBurstingEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "DataCachePL", + "Terraform": null, + "Required": false + }, + { + "ROS": "DataCacheProvisionedIops", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": "DnsConfigNameServers", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "DnsConfigOptions", + "Terraform": "dns_config_options", + "Required": false + }, + { + "ROS": "DnsConfigSearches", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "DnsPolicy", + "Terraform": "dns_policy", + "Required": false + }, + { + "ROS": "EgressBandwidth", + "Terraform": "egress_bandwidth", + "Required": false + }, + { + "ROS": "EipBandwidth", + "Terraform": "eip_bandwidth", + "Required": false + }, + { + "ROS": null, + "Terraform": "enable_sls", + "Required": false + }, + { + "ROS": "EphemeralStorage", + "Terraform": "ephemeral_storage", + "Required": false + }, + { + "ROS": null, + "Terraform": "force_delete", + "Required": false + }, + { + "ROS": "HostAliases", + "Terraform": "host_aliases", + "Required": false, + "Properties": [ + { + "ROS": "Hostnames", + "Terraform": "hostnames", + "Required": false + }, + { + "ROS": "Ip", + "Terraform": "ip", + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "HostName", + "Terraform": "host_name", + "Required": false + }, + { + "ROS": "ImageRegistryCredentials", + "Terraform": "image_registry_credentials", + "Required": false, + "Properties": [ + { + "ROS": "Password", + "Terraform": "password", + "Required": true + }, + { + "ROS": "Server", + "Terraform": "server", + "Required": true + }, + { + "ROS": null, + "Terraform": "username", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "ImageSnapshotId", + "Terraform": "image_snapshot_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Snapshot" + } + ] + }, + { + "ROS": "IngressBandwidth", + "Terraform": "ingress_bandwidth", + "Required": false + }, + { + "ROS": "InitContainers", + "Terraform": "init_containers", + "Required": false, + "Properties": [ + { + "ROS": "Args", + "Terraform": "args", + "Required": false + }, + { + "ROS": "Commands", + "Terraform": "commands", + "Required": false + }, + { + "ROS": "Cpu", + "Terraform": "cpu", + "Required": false + }, + { + "ROS": null, + "Terraform": "environment_vars", + "Required": false + }, + { + "ROS": "Gpu", + "Terraform": "gpu", + "Required": false + }, + { + "ROS": "Image", + "Terraform": "image", + "Required": true + }, + { + "ROS": "ImagePullPolicy", + "Terraform": "image_pull_policy", + "Required": false + }, + { + "ROS": "Memory", + "Terraform": "memory", + "Required": false + }, + { + "ROS": "Name", + "Terraform": "name", + "Required": true + }, + { + "ROS": null, + "Terraform": "ports", + "Required": false + }, + { + "ROS": null, + "Terraform": "security_context_capability_adds", + "Required": false + }, + { + "ROS": null, + "Terraform": "security_context_read_only_root_file_system", + "Required": false + }, + { + "ROS": "SecurityContextRunAsUser", + "Terraform": "security_context_run_as_user", + "Required": false + }, + { + "ROS": null, + "Terraform": "volume_mounts", + "Required": false + }, + { + "ROS": "WorkingDir", + "Terraform": "working_dir", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "InstanceFamilyLevel", + "Terraform": "instance_family_level", + "Required": false + }, + { + "ROS": "InstanceTypes", + "Terraform": "instance_types", + "Required": false + }, + { + "ROS": "Ipv6AddressCount", + "Terraform": "ipv6_address_count", + "Required": false + }, + { + "ROS": "LoadBalancerWeight", + "Terraform": "load_balancer_weight", + "Required": false + }, + { + "ROS": "Memory", + "Terraform": "memory", + "Required": false + }, + { + "ROS": "NtpServers", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "RamRoleName", + "Terraform": "ram_role_name", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "RestartPolicy", + "Terraform": "restart_policy", + "Required": false + }, + { + "ROS": "ScalingConfigurationName", + "Terraform": "scaling_configuration_name", + "Required": true + }, + { + "ROS": "ScalingGroupId", + "Terraform": "scaling_group_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ESS::ScalingGroup" + } + ] + }, + { + "ROS": "SecurityContextSysctls", + "Terraform": "security_context_sysctls", + "Required": false + }, + { + "ROS": "SecurityGroupId", + "Terraform": "security_group_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "SpotPriceLimit", + "Terraform": "spot_price_limit", + "Required": false + }, + { + "ROS": "SpotStrategy", + "Terraform": "spot_strategy", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "TerminationGracePeriodSeconds", + "Terraform": "termination_grace_period_seconds", + "Required": false + }, + { + "ROS": "Volumes", + "Terraform": "volumes", + "Required": false, + "Properties": [ + { + "ROS": "ConfigFileVolumeConfigFileToPaths", + "Terraform": "config_file_volume_config_file_to_paths", + "Required": false, + "Properties": [ + { + "ROS": "Content", + "Terraform": "content", + "Required": false + }, + { + "ROS": "Mode", + "Terraform": "mode", + "Required": false + }, + { + "ROS": "Path", + "Terraform": "path", + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "ConfigFileVolumeDefaultMode", + "Terraform": "config_file_volume_default_mode", + "Required": false + }, + { + "ROS": "DiskVolumeDiskId", + "Terraform": "disk_volume_disk_id", + "Required": false + }, + { + "ROS": "DiskVolumeDiskSize", + "Terraform": "disk_volume_disk_size", + "Required": false + }, + { + "ROS": null, + "Terraform": "disk_volume_fs_type", + "Required": false + }, + { + "ROS": "EmptyDirVolumeMedium", + "Terraform": "empty_dir_volume_medium", + "Required": false + }, + { + "ROS": "EmptyDirVolumeSizeLimit", + "Terraform": "empty_dir_volume_size_limit", + "Required": false + }, + { + "ROS": "FlexVolumeDriver", + "Terraform": "flex_volume_driver", + "Required": false + }, + { + "ROS": "FlexVolumeFsType", + "Terraform": "flex_volume_fs_type", + "Required": false + }, + { + "ROS": "FlexVolumeOptions", + "Terraform": "flex_volume_options", + "Required": false + }, + { + "ROS": "HostPathVolumePath", + "Terraform": "host_path_volume_path", + "Required": false + }, + { + "ROS": "HostPathVolumeType", + "Terraform": "host_path_volume_type", + "Required": false + }, + { + "ROS": "Name", + "Terraform": "name", + "Required": true + }, + { + "ROS": null, + "Terraform": "nfs_volume_path", + "Required": false + }, + { + "ROS": null, + "Terraform": "nfs_volume_read_only", + "Required": false + }, + { + "ROS": null, + "Terraform": "nfs_volume_server", + "Required": false + }, + { + "ROS": "Type", + "Terraform": "type", + "Required": true + } + ], + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "ScalingConfigurationId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ESS::LifecycleHook", + "Terraform": "alicloud_ess_lifecycle_hook" + }, + "ProductCode": "ess", + "Name": { + "zh": "ESS生命周期hook", + "en": "Auto Scaling Lifecycle Hook" + }, + "Properties": [ + { + "ROS": "DefaultResult", + "Terraform": "default_result", + "Required": false + }, + { + "ROS": "HeartbeatTimeout", + "Terraform": "heartbeat_timeout", + "Required": false + }, + { + "ROS": "LifecycleTransition", + "Terraform": "lifecycle_transition", + "Required": true + }, + { + "ROS": "LifecycleHookName", + "Terraform": "name", + "Required": false + }, + { + "ROS": "NotificationArn", + "Terraform": "notification_arn", + "Required": false + }, + { + "ROS": "NotificationMetadata", + "Terraform": "notification_metadata", + "Required": false + }, + { + "ROS": "ScalingGroupId", + "Terraform": "scaling_group_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + } + ], + "Attributes": [ + { + "ROS": "LifecycleHookId", + "Terraform": null, + "PrimaryKey": true + }, + { + "ROS": "ScalingGroupId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ESS::LoadBalancerAttachment", + "Terraform": null + }, + "ProductCode": "ess", + "Name": { + "zh": "ESS添加负载均衡实例", + "en": "Add SLB Instance to Auto Scaling" + }, + "Properties": [ + { + "ROS": "ForceAttach", + "Terraform": null, + "Required": false + }, + { + "ROS": "LoadBalancerConfigs", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::SLB::LoadBalancer" + } + ], + "Properties": [ + { + "ROS": "LoadBalancerId", + "Terraform": null, + "Required": false + }, + { + "ROS": "Weight", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "LoadBalancers", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "ScalingGroupId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ESS::ScalingGroup" + } + ] + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ESS::ScalingConfiguration", + "Terraform": "alicloud_ess_scaling_configuration" + }, + "ProductCode": "ess", + "Name": { + "zh": "ESS伸缩配置", + "en": "Scaling Configuration of Auto Scaling" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "active", + "Required": false + }, + { + "ROS": "Affinity", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "Classic", + "Required": false + }, + { + "ROS": "Cpu", + "Terraform": null, + "Required": false + }, + { + "ROS": "CreditSpecification", + "Terraform": "credit_specification", + "Required": false + }, + { + "ROS": "DiskMappings", + "Terraform": "data_disk", + "Required": false, + "Properties": [ + { + "ROS": "AutoSnapshotPolicyId", + "Terraform": "auto_snapshot_policy_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::AutoSnapshotPolicy" + } + ] + }, + { + "ROS": "Category", + "Terraform": "category", + "Required": false + }, + { + "ROS": "DeleteWithInstance", + "Terraform": "delete_with_instance", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "Encrypted", + "Terraform": "encrypted", + "Required": false + }, + { + "ROS": "KMSKeyId", + "Terraform": "kms_key_id", + "Required": false + }, + { + "ROS": "DiskName", + "Terraform": "name", + "Required": false + }, + { + "ROS": "PerformanceLevel", + "Terraform": "performance_level", + "Required": false + }, + { + "ROS": "ProvisionedIops", + "Terraform": "provisioned_iops", + "Required": false + }, + { + "ROS": "Size", + "Terraform": "size", + "Required": false + }, + { + "ROS": "SnapshotId", + "Terraform": "snapshot_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Snapshot" + } + ] + } + ], + "Type": "list" + }, + { + "ROS": "DedicatedHostId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::DedicatedHost" + } + ] + }, + { + "ROS": null, + "Terraform": "deletion_protection", + "Required": false + }, + { + "ROS": "DeploymentSetId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::DeploymentSet" + } + ] + }, + { + "ROS": null, + "Terraform": "enable", + "Required": false + }, + { + "ROS": null, + "Terraform": "force_delete", + "Required": false + }, + { + "ROS": "HostName", + "Terraform": "host_name", + "Required": false + }, + { + "ROS": "HpcClusterId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::HpcCluster" + } + ] + }, + { + "ROS": "ImageFamily", + "Terraform": null, + "Required": false + }, + { + "ROS": "ImageId", + "Terraform": "image_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::CustomImage" + } + ] + }, + { + "ROS": "ImageName", + "Terraform": "image_name", + "Required": false + }, + { + "ROS": "ImageOptionsLoginAsNonRoot", + "Terraform": "image_options_login_as_non_root", + "Required": false + }, + { + "ROS": "InstanceDescription", + "Terraform": "instance_description", + "Required": false + }, + { + "ROS": "InstanceId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Instance" + }, + { + "ResourceType": "ROS/ALIYUN::ECS::InstanceGroup" + } + ] + }, + { + "ROS": "InstanceName", + "Terraform": "instance_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_pattern_info", + "Required": false + }, + { + "ROS": "InstancePatternInfos", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Architectures", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "BurstablePerformance", + "Terraform": null, + "Required": false + }, + { + "ROS": "Cores", + "Terraform": null, + "Required": false + }, + { + "ROS": "ExcludedInstanceTypes", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "InstanceFamilyLevel", + "Terraform": null, + "Required": false + }, + { + "ROS": "MaxPrice", + "Terraform": null, + "Required": false + }, + { + "ROS": "Memory", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "InstanceType", + "Terraform": "instance_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_type_override", + "Required": false + }, + { + "ROS": "InstanceTypeOverrides", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "InstanceType", + "Terraform": null, + "Required": false + }, + { + "ROS": "WeightedCapacity", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "InstanceTypes", + "Terraform": "instance_types", + "Required": false + }, + { + "ROS": "InternetChargeType", + "Terraform": "internet_charge_type", + "Required": false + }, + { + "ROS": "InternetMaxBandwidthIn", + "Terraform": "internet_max_bandwidth_in", + "Required": false + }, + { + "ROS": "InternetMaxBandwidthOut", + "Terraform": "internet_max_bandwidth_out", + "Required": false + }, + { + "ROS": "IoOptimized", + "Terraform": null, + "Required": false + }, + { + "ROS": "Ipv6AddressCount", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "is_outdated", + "Required": false + }, + { + "ROS": "KeyPairName", + "Terraform": "key_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "kms_encrypted_password", + "Required": false + }, + { + "ROS": null, + "Terraform": "kms_encryption_context", + "Required": false + }, + { + "ROS": "LoadBalancerWeight", + "Terraform": null, + "Required": false + }, + { + "ROS": "Memory", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "override", + "Required": false + }, + { + "ROS": "Password", + "Terraform": "password", + "Required": false + }, + { + "ROS": "PasswordInherit", + "Terraform": "password_inherit", + "Required": false + }, + { + "ROS": "PrivatePoolOptions", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Id", + "Terraform": null, + "Required": false + }, + { + "ROS": "MatchCriteria", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "RamRoleName", + "Terraform": "role_name", + "Required": false + }, + { + "ROS": "ScalingConfigurationName", + "Terraform": "scaling_configuration_name", + "Required": false + }, + { + "ROS": "ScalingGroupId", + "Terraform": "scaling_group_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ESS::ScalingGroup" + } + ] + }, + { + "ROS": "SecurityEnhancementStrategy", + "Terraform": "security_enhancement_strategy", + "Required": false + }, + { + "ROS": "SecurityGroupId", + "Terraform": "security_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "SecurityGroupIds", + "Terraform": "security_group_ids", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "SpotDuration", + "Terraform": "spot_duration", + "Required": false + }, + { + "ROS": "SpotInterruptionBehavior", + "Terraform": null, + "Required": false + }, + { + "ROS": "SpotPriceLimit", + "Terraform": "spot_price_limit", + "Required": false + }, + { + "ROS": "SpotPriceLimitForInstanceType", + "Terraform": null, + "Required": false + }, + { + "ROS": "SpotStrategy", + "Terraform": "spot_strategy", + "Required": false + }, + { + "ROS": null, + "Terraform": "substitute", + "Required": false + }, + { + "ROS": "SystemDiskAutoSnapshotPolicyId", + "Terraform": "system_disk_auto_snapshot_policy_id", + "Required": false + }, + { + "ROS": "SystemDiskBurstingEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskCategories", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "SystemDiskCategory", + "Terraform": "system_disk_category", + "Required": false + }, + { + "ROS": "SystemDiskDescription", + "Terraform": "system_disk_description", + "Required": false + }, + { + "ROS": "SystemDiskDiskName", + "Terraform": null, + "Required": false + }, + { + "ROS": "SystemDiskEncryptAlgorithm", + "Terraform": "system_disk_encrypt_algorithm", + "Required": false + }, + { + "ROS": "SystemDiskEncrypted", + "Terraform": "system_disk_encrypted", + "Required": false + }, + { + "ROS": "SystemDiskKMSKeyId", + "Terraform": "system_disk_kms_key_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "system_disk_name", + "Required": false + }, + { + "ROS": "SystemDiskPerformanceLevel", + "Terraform": "system_disk_performance_level", + "Required": false + }, + { + "ROS": "SystemDiskProvisionedIops", + "Terraform": "system_disk_provisioned_iops", + "Required": false + }, + { + "ROS": "SystemDiskSize", + "Terraform": "system_disk_size", + "Required": false + }, + { + "ROS": "TagList", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "Tenancy", + "Terraform": null, + "Required": false + }, + { + "ROS": "UserData", + "Terraform": "user_data", + "Required": false + }, + { + "ROS": "ZoneId", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "ScalingConfigurationId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "ScalingGroupId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ESS::ScalingGroup", + "Terraform": "alicloud_ess_scaling_group" + }, + "ProductCode": "ess", + "Name": { + "zh": "ESS伸缩组", + "en": "Scaling Group of Auto Scaling" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "alb_server_group", + "Required": false + }, + { + "ROS": "AllocationStrategy", + "Terraform": "allocation_strategy", + "Required": false + }, + { + "ROS": "AzBalance", + "Terraform": "az_balance", + "Required": false + }, + { + "ROS": "CompensateWithOnDemand", + "Terraform": null, + "Required": false + }, + { + "ROS": "ContainerGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECI::ContainerGroup" + } + ] + }, + { + "ROS": "CustomPolicyARN", + "Terraform": null, + "Required": false + }, + { + "ROS": "DBInstanceIds", + "Terraform": "db_instance_ids", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::RDS::DBInstance" + } + ] + }, + { + "ROS": "DefaultCooldown", + "Terraform": "default_cooldown", + "Required": false + }, + { + "ROS": "DesiredCapacity", + "Terraform": "desired_capacity", + "Required": false + }, + { + "ROS": "GroupDeletionProtection", + "Terraform": "group_deletion_protection", + "Required": false + }, + { + "ROS": "GroupType", + "Terraform": "group_type", + "Required": false + }, + { + "ROS": "HealthCheckType", + "Terraform": "health_check_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "health_check_types", + "Required": false + }, + { + "ROS": "InstanceId", + "Terraform": "instance_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Instance" + }, + { + "ResourceType": "ROS/ALIYUN::ECS::InstanceGroup" + } + ] + }, + { + "ROS": "LaunchTemplateId", + "Terraform": "launch_template_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::LaunchTemplate" + } + ] + }, + { + "ROS": null, + "Terraform": "launch_template_override", + "Required": false + }, + { + "ROS": "LaunchTemplateOverrides", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "InstanceType", + "Terraform": null, + "Required": false + }, + { + "ROS": "SpotPriceLimit", + "Terraform": null, + "Required": false + }, + { + "ROS": "WeightedCapacity", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "LaunchTemplateVersion", + "Terraform": "launch_template_version", + "Required": false + }, + { + "ROS": "LoadBalancerIds", + "Terraform": "loadbalancer_ids", + "Required": false + }, + { + "ROS": "MaxInstanceLifetime", + "Terraform": "max_instance_lifetime", + "Required": false + }, + { + "ROS": "MaxSize", + "Terraform": "max_size", + "Required": true + }, + { + "ROS": "MinSize", + "Terraform": "min_size", + "Required": true + }, + { + "ROS": "MultiAZPolicy", + "Terraform": "multi_az_policy", + "Required": false + }, + { + "ROS": "NotificationConfigurations", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "NotificationArn", + "Terraform": null, + "Required": true + }, + { + "ROS": "NotificationTypes", + "Terraform": null, + "Required": true, + "Properties": {}, + "Type": "list" + } + ], + "Type": "list" + }, + { + "ROS": "OnDemandBaseCapacity", + "Terraform": "on_demand_base_capacity", + "Required": false + }, + { + "ROS": "OnDemandPercentageAboveBaseCapacity", + "Terraform": "on_demand_percentage_above_base_capacity", + "Required": false + }, + { + "ROS": "ProtectedInstances", + "Terraform": "protected_instances", + "Required": false + }, + { + "ROS": "RemovalPolicys", + "Terraform": "removal_policies", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "ScalingGroupName", + "Terraform": "scaling_group_name", + "Required": false + }, + { + "ROS": "ScalingPolicy", + "Terraform": "scaling_policy", + "Required": false + }, + { + "ROS": "ServerGroups", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Port", + "Terraform": null, + "Required": true + }, + { + "ROS": "ServerGroupId", + "Terraform": null, + "Required": true + }, + { + "ROS": "Type", + "Terraform": null, + "Required": true + }, + { + "ROS": "Weight", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "SpotAllocationStrategy", + "Terraform": "spot_allocation_strategy", + "Required": false + }, + { + "ROS": "SpotInstancePools", + "Terraform": "spot_instance_pools", + "Required": false + }, + { + "ROS": "SpotInstanceRemedy", + "Terraform": "spot_instance_remedy", + "Required": false + }, + { + "ROS": "StandbyInstances", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "VSwitchIds", + "Terraform": "vswitch_ids", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": "ScalingGroupId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "ScalingGroupName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ESS::ScalingGroupEnable", + "Terraform": null + }, + "ProductCode": "ess", + "Name": { + "zh": "启用ESS伸缩组", + "en": "Enable Scaling Group of Auto Scaling" + }, + "Properties": [ + { + "ROS": "AttachOptions", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Entrusted", + "Terraform": null, + "Required": false + }, + { + "ROS": "LifecycleHook", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "DetachOptions", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "DecreaseDesiredCapacity", + "Terraform": null, + "Required": false + }, + { + "ROS": "DetachOption", + "Terraform": null, + "Required": false + }, + { + "ROS": "LifecycleHook", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "InstanceIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Instance" + }, + { + "ResourceType": "ROS/ALIYUN::ECS::InstanceGroup" + } + ], + "Type": "list" + }, + { + "ROS": "RemoveInstanceIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "ScalingConfigurationId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ESS::ScalingConfiguration" + } + ] + }, + { + "ROS": "ScalingGroupId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ESS::ScalingGroup" + } + ] + }, + { + "ROS": "ScalingRuleAris", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "ScalingRuleArisExecuteVersion", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "LifecycleState", + "Terraform": null + }, + { + "ROS": "ScalingGroupId", + "Terraform": null + }, + { + "ROS": "ScalingInstanceDetails", + "Terraform": null + }, + { + "ROS": "ScalingInstances", + "Terraform": null, + "Primary": true + }, + { + "ROS": "ScalingRuleArisExecuteErrorInfo", + "Terraform": null + }, + { + "ROS": "ScalingRuleArisExecuteResultInstancesAdded", + "Terraform": null + }, + { + "ROS": "ScalingRuleArisExecuteResultInstancesRemoved", + "Terraform": null + }, + { + "ROS": "ScalingRuleArisExecuteResultNumberOfAddedInstances", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ESS::ScalingRule", + "Terraform": "alicloud_ess_scaling_rule" + }, + "ProductCode": "ess", + "Name": { + "zh": "ESS伸缩规则", + "en": "Scaling Rule of Auto Scaling" + }, + "Properties": [ + { + "ROS": "AdjustmentType", + "Terraform": "adjustment_type", + "Required": false + }, + { + "ROS": "AdjustmentValue", + "Terraform": "adjustment_value", + "Required": false + }, + { + "ROS": null, + "Terraform": "alarm_dimension", + "Required": false + }, + { + "ROS": null, + "Terraform": "ari", + "Required": false + }, + { + "ROS": "Cooldown", + "Terraform": "cooldown", + "Required": false + }, + { + "ROS": "DisableScaleIn", + "Terraform": "disable_scale_in", + "Required": false + }, + { + "ROS": "EstimatedInstanceWarmup", + "Terraform": "estimated_instance_warmup", + "Required": false + }, + { + "ROS": "InitialMaxSize", + "Terraform": "initial_max_size", + "Required": false + }, + { + "ROS": "MetricName", + "Terraform": "metric_name", + "Required": false + }, + { + "ROS": "MinAdjustmentMagnitude", + "Terraform": "min_adjustment_magnitude", + "Required": false + }, + { + "ROS": "PredictiveScalingMode", + "Terraform": "predictive_scaling_mode", + "Required": false + }, + { + "ROS": "PredictiveTaskBufferTime", + "Terraform": "predictive_task_buffer_time", + "Required": false + }, + { + "ROS": "PredictiveValueBehavior", + "Terraform": "predictive_value_behavior", + "Required": false + }, + { + "ROS": "PredictiveValueBuffer", + "Terraform": "predictive_value_buffer", + "Required": false + }, + { + "ROS": "ScaleInEvaluationCount", + "Terraform": "scale_in_evaluation_count", + "Required": false + }, + { + "ROS": "ScaleOutEvaluationCount", + "Terraform": "scale_out_evaluation_count", + "Required": false + }, + { + "ROS": "ScalingGroupId", + "Terraform": "scaling_group_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ESS::ScalingGroup" + } + ] + }, + { + "ROS": "ScalingRuleName", + "Terraform": "scaling_rule_name", + "Required": false + }, + { + "ROS": "ScalingRuleType", + "Terraform": "scaling_rule_type", + "Required": false + }, + { + "ROS": "StepAdjustment", + "Terraform": "step_adjustment", + "Required": false, + "Properties": [ + { + "ROS": "MetricIntervalLowerBound", + "Terraform": "metric_interval_lower_bound", + "Required": false + }, + { + "ROS": "MetricIntervalUpperBound", + "Terraform": "metric_interval_upper_bound", + "Required": false + }, + { + "ROS": "ScalingAdjustment", + "Terraform": "scaling_adjustment", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "TargetValue", + "Terraform": "target_value", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "ScalingRuleId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "ScalingRuleAri", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ESS::ScheduledTask", + "Terraform": "alicloud_ess_scheduled_task" + }, + "ProductCode": "ess", + "Name": { + "zh": "ESS定时任务", + "en": "Auto Scaling Scheduled Task" + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "DesiredCapacity", + "Terraform": "desired_capacity", + "Required": false + }, + { + "ROS": "LaunchExpirationTime", + "Terraform": "launch_expiration_time", + "Required": false + }, + { + "ROS": "LaunchTime", + "Terraform": "launch_time", + "Required": true + }, + { + "ROS": "MaxValue", + "Terraform": "max_value", + "Required": false + }, + { + "ROS": "MinValue", + "Terraform": "min_value", + "Required": false + }, + { + "ROS": "RecurrenceEndTime", + "Terraform": "recurrence_end_time", + "Required": false + }, + { + "ROS": "RecurrenceType", + "Terraform": "recurrence_type", + "Required": false + }, + { + "ROS": "RecurrenceValue", + "Terraform": "recurrence_value", + "Required": false + }, + { + "ROS": "ScalingGroupId", + "Terraform": "scaling_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ESS::ScalingGroup" + } + ] + }, + { + "ROS": "ScheduledAction", + "Terraform": "scheduled_action", + "Required": false + }, + { + "ROS": "ScheduledTaskName", + "Terraform": "scheduled_task_name", + "Required": false + }, + { + "ROS": "TaskEnabled", + "Terraform": "task_enabled", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "ScheduledTaskId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ESS::ServerGroupAttachment", + "Terraform": "alicloud_ess_alb_server_group_attachment" + }, + "ProductCode": "ess", + "Name": { + "zh": "添加ESS服务器组", + "en": "Add Server Group to Auto Scaling" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "alb_server_group_id", + "Required": false + }, + { + "ROS": "ForceAttach", + "Terraform": "force_attach", + "Required": false + }, + { + "ROS": null, + "Terraform": "port", + "Required": false + }, + { + "ROS": "ScalingGroupId", + "Terraform": "scaling_group_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ESS::ScalingGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "server_group_id", + "Required": false + }, + { + "ROS": "ServerGroups", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "Port", + "Terraform": null, + "Required": true + }, + { + "ROS": "ServerGroupId", + "Terraform": null, + "Required": true + }, + { + "ROS": "Type", + "Terraform": null, + "Required": true + }, + { + "ROS": "Weight", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": null, + "Terraform": "type", + "Required": false + }, + { + "ROS": null, + "Terraform": "weight", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "ScalingActivityId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "ScalingActivityId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ESS::VServerGroupAttachment", + "Terraform": null + }, + "ProductCode": "ess", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "ForceAttach", + "Terraform": null, + "Required": false + }, + { + "ROS": "ScalingGroupId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ESS::ScalingGroup" + } + ] + }, + { + "ROS": "VServerGroups", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "LoadBalancerId", + "Terraform": null, + "Required": true + }, + { + "ROS": "VServerGroupAttributes", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "Port", + "Terraform": null, + "Required": true + }, + { + "ROS": "VServerGroupId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::SLB::VServerGroup" + } + ] + }, + { + "ROS": "Weight", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + } + ], + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "ScalingGroupId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::EdsUser::User", + "Terraform": null + }, + "ProductCode": "gws", + "Name": { + "zh": "EdsUser User", + "en": "EDS Simple User Management Convenience User" + }, + "Properties": [ + { + "ROS": "Email", + "Terraform": null, + "Required": false + }, + { + "ROS": "EndUserId", + "Terraform": null, + "Required": true + }, + { + "ROS": "OrgId", + "Terraform": null, + "Required": false + }, + { + "ROS": "OwnerType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Password", + "Terraform": null, + "Required": false + }, + { + "ROS": "Phone", + "Terraform": null, + "Required": false + }, + { + "ROS": "Remark", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "EndUserId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ElasticSearch::Instance", + "Terraform": "alicloud_elasticsearch_instance" + }, + "ProductCode": "elasticsearch", + "Name": { + "zh": "Elasticsearch实例", + "en": "Elasticsearch Instance" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "auto_renew_duration", + "Required": false + }, + { + "ROS": null, + "Terraform": "client_node_amount", + "Required": false + }, + { + "ROS": null, + "Terraform": "client_node_spec", + "Required": false + }, + { + "ROS": "DataNode", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "Amount", + "Terraform": null, + "Required": true + }, + { + "ROS": "DiskEncryption", + "Terraform": null, + "Required": false + }, + { + "ROS": "DiskSize", + "Terraform": null, + "Required": true + }, + { + "ROS": "DiskType", + "Terraform": null, + "Required": true + }, + { + "ROS": "PerformanceLevel", + "Terraform": null, + "Required": false + }, + { + "ROS": "Spec", + "Terraform": null, + "Required": true + } + ] + }, + { + "ROS": null, + "Terraform": "data_node_amount", + "Required": false + }, + { + "ROS": null, + "Terraform": "data_node_disk_encrypted", + "Required": false + }, + { + "ROS": null, + "Terraform": "data_node_disk_performance_level", + "Required": false + }, + { + "ROS": null, + "Terraform": "data_node_disk_size", + "Required": false + }, + { + "ROS": null, + "Terraform": "data_node_disk_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "data_node_spec", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "domain", + "Required": false + }, + { + "ROS": "EnableKibanaPrivate", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "enable_kibana_private_network", + "Required": false + }, + { + "ROS": "EnableKibanaPublic", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "enable_kibana_public_network", + "Required": false + }, + { + "ROS": "EnablePublic", + "Terraform": "enable_public", + "Required": false + }, + { + "ROS": "InstanceCategory", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceChargeType", + "Terraform": "instance_charge_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "kibana_domain", + "Required": false + }, + { + "ROS": "KibanaNode", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Spec", + "Terraform": null, + "Required": true + } + ] + }, + { + "ROS": null, + "Terraform": "kibana_node_spec", + "Required": false + }, + { + "ROS": null, + "Terraform": "kibana_port", + "Required": false + }, + { + "ROS": null, + "Terraform": "kibana_private_security_group_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "kibana_private_whitelist", + "Required": false + }, + { + "ROS": "KibanaWhitelist", + "Terraform": "kibana_whitelist", + "Required": false + }, + { + "ROS": null, + "Terraform": "kms_encrypted_password", + "Required": false + }, + { + "ROS": null, + "Terraform": "kms_encryption_context", + "Required": false + }, + { + "ROS": "MasterNode", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Amount", + "Terraform": null, + "Required": false + }, + { + "ROS": "DiskSize", + "Terraform": null, + "Required": false + }, + { + "ROS": "DiskType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Spec", + "Terraform": null, + "Required": true + } + ] + }, + { + "ROS": null, + "Terraform": "master_node_disk_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "master_node_spec", + "Required": false + }, + { + "ROS": "Password", + "Terraform": "password", + "Required": true + }, + { + "ROS": "Period", + "Terraform": "period", + "Required": false + }, + { + "ROS": "PeriodUnit", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "port", + "Required": false + }, + { + "ROS": "PrivateWhitelist", + "Terraform": "private_whitelist", + "Required": false + }, + { + "ROS": null, + "Terraform": "protocol", + "Required": false + }, + { + "ROS": null, + "Terraform": "public_domain", + "Required": false + }, + { + "ROS": null, + "Terraform": "public_port", + "Required": false + }, + { + "ROS": "PublicWhitelist", + "Terraform": "public_whitelist", + "Required": false + }, + { + "ROS": null, + "Terraform": "renewal_duration_unit", + "Required": false + }, + { + "ROS": null, + "Terraform": "renew_status", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "setting_config", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "Version", + "Terraform": "version", + "Required": true + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": null, + "Terraform": "warm_node_amount", + "Required": false + }, + { + "ROS": null, + "Terraform": "warm_node_disk_encrypted", + "Required": false + }, + { + "ROS": null, + "Terraform": "warm_node_disk_size", + "Required": false + }, + { + "ROS": null, + "Terraform": "warm_node_disk_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "warm_node_spec", + "Required": false + }, + { + "ROS": "YMLConfig", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "AuditLog", + "Terraform": null, + "Required": false + }, + { + "ROS": "CreateIndex", + "Terraform": null, + "Required": false + }, + { + "ROS": "DestructiveRequiresName", + "Terraform": null, + "Required": false + }, + { + "ROS": "OtherConfigs", + "Terraform": null, + "Required": false + }, + { + "ROS": "Watcher", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "ZoneCount", + "Terraform": "zone_count", + "Required": false + }, + { + "ROS": "ZoneId", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": "Domain", + "Terraform": "domain" + }, + { + "ROS": "InstanceId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "InstanceChargeType", + "Terraform": null + }, + { + "ROS": "KibanaDomain", + "Terraform": "kibana_domain" + }, + { + "ROS": "KibanaPort", + "Terraform": "kibana_port" + }, + { + "ROS": "Port", + "Terraform": "port" + }, + { + "ROS": "PublicDomain", + "Terraform": "public_domain" + }, + { + "ROS": null, + "Terraform": "public_port" + }, + { + "ROS": "Status", + "Terraform": "status" + }, + { + "ROS": "Version", + "Terraform": null + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ElasticSearchServerless::App", + "Terraform": null + }, + "ProductCode": "elasticsearch", + "Name": { + "zh": "ElasticSearchServerless App", + "en": "Elasticsearch Serverless App" + }, + "Properties": [ + { + "ROS": "AppName", + "Terraform": null, + "Required": true + }, + { + "ROS": "AppVersion", + "Terraform": null, + "Required": false + }, + { + "ROS": "Authentication", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "BasicAuth", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "Password", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + } + ] + }, + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "Network", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Enabled", + "Terraform": null, + "Required": true + }, + { + "ROS": "Type", + "Terraform": null, + "Required": true + }, + { + "ROS": "WhiteIpGroup", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "GroupName", + "Terraform": null, + "Required": true + }, + { + "ROS": "Ips", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + } + ], + "Type": "list" + }, + { + "ROS": "PrivateNetwork", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Enabled", + "Terraform": null, + "Required": true + }, + { + "ROS": "PvlEndpointId", + "Terraform": null, + "Required": true + }, + { + "ROS": "Type", + "Terraform": null, + "Required": true + }, + { + "ROS": "VpcId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "WhiteIpGroup", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "GroupName", + "Terraform": null, + "Required": true + }, + { + "ROS": "Ips", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + } + ], + "Type": "list" + }, + { + "ROS": "QuotaInfo", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "AppType", + "Terraform": null, + "Required": true + }, + { + "ROS": "Cu", + "Terraform": null, + "Required": true + }, + { + "ROS": "Storage", + "Terraform": null, + "Required": true + } + ] + } + ], + "Attributes": [ + { + "ROS": "InstanceId", + "Terraform": null + }, + { + "ROS": "PrivateESDomain", + "Terraform": null + }, + { + "ROS": "PrivateKibanaDomain", + "Terraform": null + }, + { + "ROS": "PublicESDomain", + "Terraform": null + }, + { + "ROS": "PublicKibanaDomain", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::EventBridge::Rule", + "Terraform": "alicloud_event_bridge_rule" + }, + "ProductCode": "eventbridge", + "Name": { + "zh": "EventBridge Rule", + "en": "EventBridge Rule" + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "EventBusName", + "Terraform": "event_bus_name", + "Required": true + }, + { + "ROS": "FilterPattern", + "Terraform": "filter_pattern", + "Required": true + }, + { + "ROS": "RuleName", + "Terraform": "rule_name", + "Required": true + }, + { + "ROS": "Status", + "Terraform": "status", + "Required": false + }, + { + "ROS": "Targets", + "Terraform": "targets", + "Required": true, + "Properties": [ + { + "ROS": null, + "Terraform": "dead_letter_queue", + "Required": false + }, + { + "ROS": "Endpoint", + "Terraform": "endpoint", + "Required": true + }, + { + "ROS": "ParamList", + "Terraform": "param_list", + "Required": true, + "Properties": [ + { + "ROS": "Form", + "Terraform": "form", + "Required": true + }, + { + "ROS": "ResourceKey", + "Terraform": "resource_key", + "Required": true + }, + { + "ROS": "Template", + "Terraform": "template", + "Required": false + }, + { + "ROS": "Value", + "Terraform": "value", + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "PushRetryStrategy", + "Terraform": "push_retry_strategy", + "Required": false + }, + { + "ROS": null, + "Terraform": "target_id", + "Required": false + }, + { + "ROS": "Type", + "Terraform": "type", + "Required": true + } + ], + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "EventBusName", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "RuleARN", + "Terraform": null + }, + { + "ROS": "RuleName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::FC3::ConcurrencyConfig", + "Terraform": "alicloud_fcv3_concurrency_config" + }, + "ProductCode": "fc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "FunctionName", + "Terraform": "function_name", + "Required": true + }, + { + "ROS": "ReservedConcurrency", + "Terraform": "reserved_concurrency", + "Required": true + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::FC3::CustomDomain", + "Terraform": "alicloud_fcv3_custom_domain" + }, + "ProductCode": "fc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "AuthConfig", + "Terraform": "auth_config", + "Required": true + }, + { + "ROS": "CertConfig", + "Terraform": "cert_config", + "Required": false + }, + { + "ROS": null, + "Terraform": "custom_domain_name", + "Required": false + }, + { + "ROS": "DomainName", + "Terraform": null, + "Required": true + }, + { + "ROS": "Protocol", + "Terraform": "protocol", + "Required": true + }, + { + "ROS": "RouteConfig", + "Terraform": "route_config", + "Required": false + }, + { + "ROS": "TlsConfig", + "Terraform": "tls_config", + "Required": false + }, + { + "ROS": "WafConfig", + "Terraform": "waf_config", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "DomainName", + "Terraform": null + }, + { + "ROS": "DomainName", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::FC3::Function", + "Terraform": "alicloud_fcv3_function" + }, + "ProductCode": "fc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "Code", + "Terraform": "code", + "Required": false + }, + { + "ROS": "Cpu", + "Terraform": "cpu", + "Required": false + }, + { + "ROS": "CustomContainerConfig", + "Terraform": "custom_container_config", + "Required": false + }, + { + "ROS": "CustomDns", + "Terraform": "custom_dns", + "Required": false + }, + { + "ROS": "CustomRuntimeConfig", + "Terraform": "custom_runtime_config", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "DiskSize", + "Terraform": "disk_size", + "Required": false + }, + { + "ROS": "EnvironmentVariables", + "Terraform": "environment_variables", + "Required": false + }, + { + "ROS": "FunctionName", + "Terraform": "function_name", + "Required": true + }, + { + "ROS": "GpuConfig", + "Terraform": "gpu_config", + "Required": false + }, + { + "ROS": "Handler", + "Terraform": "handler", + "Required": true + }, + { + "ROS": "InstanceConcurrency", + "Terraform": "instance_concurrency", + "Required": false + }, + { + "ROS": "InstanceLifecycleConfig", + "Terraform": "instance_lifecycle_config", + "Required": false + }, + { + "ROS": "InternetAccess", + "Terraform": "internet_access", + "Required": false + }, + { + "ROS": "Layers", + "Terraform": "layers", + "Required": false + }, + { + "ROS": "LogConfig", + "Terraform": "log_config", + "Required": false + }, + { + "ROS": "MemorySize", + "Terraform": "memory_size", + "Required": false + }, + { + "ROS": "NasConfig", + "Terraform": "nas_config", + "Required": false + }, + { + "ROS": "OssMountConfig", + "Terraform": "oss_mount_config", + "Required": false + }, + { + "ROS": "Role", + "Terraform": "role", + "Required": false + }, + { + "ROS": "Runtime", + "Terraform": "runtime", + "Required": true + }, + { + "ROS": "Timeout", + "Terraform": "timeout", + "Required": false + }, + { + "ROS": "TracingConfig", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Params", + "Terraform": null, + "Required": false + }, + { + "ROS": "Type", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "VpcConfig", + "Terraform": "vpc_config", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "ARN", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "FunctionName", + "Terraform": null + }, + { + "ROS": "FunctionId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::FC3::ProvisionConfig", + "Terraform": "alicloud_fcv3_provision_config" + }, + "ProductCode": "fc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "AlwaysAllocateCPU", + "Terraform": "always_allocate_cpu", + "Required": false + }, + { + "ROS": "AlwaysAllocateGPU", + "Terraform": "always_allocate_gpu", + "Required": false + }, + { + "ROS": "DefaultTarget", + "Terraform": null, + "Required": true + }, + { + "ROS": "FunctionName", + "Terraform": "function_name", + "Required": true + }, + { + "ROS": "Qualifier", + "Terraform": "qualifier", + "Required": false + }, + { + "ROS": "ScheduledActions", + "Terraform": "scheduled_actions", + "Required": false + }, + { + "ROS": null, + "Terraform": "target", + "Required": false + }, + { + "ROS": "TargetTrackingPolicies", + "Terraform": "target_tracking_policies", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::FC3::Trigger", + "Terraform": "alicloud_fcv3_trigger" + }, + "ProductCode": "fc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "FunctionName", + "Terraform": "function_name", + "Required": true + }, + { + "ROS": "InvocationRole", + "Terraform": "invocation_role", + "Required": false + }, + { + "ROS": "Qualifier", + "Terraform": "qualifier", + "Required": false + }, + { + "ROS": "SourceArn", + "Terraform": "source_arn", + "Required": false + }, + { + "ROS": "TriggerConfig", + "Terraform": "trigger_config", + "Required": true + }, + { + "ROS": "TriggerName", + "Terraform": "trigger_name", + "Required": true + }, + { + "ROS": "TriggerType", + "Terraform": "trigger_type", + "Required": true + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "FunctionName", + "Terraform": null + }, + { + "ROS": "TriggerId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "TriggerName", + "Terraform": null + }, + { + "ROS": "UrlInternet", + "Terraform": null + }, + { + "ROS": "UrlIntranet", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::FC::Alias", + "Terraform": "alicloud_fc_alias" + }, + "ProductCode": "fc", + "Name": { + "zh": "FC别名", + "en": "Alias in Function Compute" + }, + "Properties": [ + { + "ROS": "AdditionalVersion", + "Terraform": null, + "Required": false + }, + { + "ROS": "AdditionalWeight", + "Terraform": null, + "Required": false + }, + { + "ROS": "AliasName", + "Terraform": "alias_name", + "Required": true + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "routing_config", + "Required": false + }, + { + "ROS": "ServiceName", + "Terraform": "service_name", + "Required": true + }, + { + "ROS": null, + "Terraform": "service_version", + "Required": false + }, + { + "ROS": "VersionId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::FC::Version" + } + ] + } + ], + "Attributes": [ + { + "ROS": "AliasName", + "Terraform": null + }, + { + "ROS": "ServiceName", + "Terraform": null + }, + { + "ROS": "VersionId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::FC::CustomDomain", + "Terraform": "alicloud_fc_custom_domain" + }, + "ProductCode": "fc", + "Name": { + "zh": "FC自定义域名", + "en": "Function Compute Custom Domain" + }, + "Properties": [ + { + "ROS": "ApiVersion", + "Terraform": null, + "Required": false + }, + { + "ROS": "CertConfig", + "Terraform": "cert_config", + "Required": false + }, + { + "ROS": "DomainName", + "Terraform": "domain_name", + "Required": true + }, + { + "ROS": "Protocol", + "Terraform": "protocol", + "Required": true + }, + { + "ROS": "RouteConfig", + "Terraform": "route_config", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "account_id" + }, + { + "ROS": null, + "Terraform": "api_version" + }, + { + "ROS": null, + "Terraform": "created_time" + }, + { + "ROS": "Domain", + "Terraform": null + }, + { + "ROS": "DomainName", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "last_modified_time" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::FC::Function", + "Terraform": "alicloud_fc_function" + }, + "ProductCode": "fc", + "Name": { + "zh": "FC函数", + "en": "Function of Function Compute" + }, + "Properties": [ + { + "ROS": "AsyncConfiguration", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Destination", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "OnFailure", + "Terraform": null, + "Required": false + }, + { + "ROS": "OnSuccess", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "MaxAsyncEventAgeInSeconds", + "Terraform": null, + "Required": false + }, + { + "ROS": "MaxAsyncRetryAttempts", + "Terraform": null, + "Required": false + }, + { + "ROS": "StatefulInvocation", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "CAPort", + "Terraform": "ca_port", + "Required": false + }, + { + "ROS": "Code", + "Terraform": "code", + "Required": false, + "Properties": [ + { + "ROS": "OssBucketName", + "Terraform": null, + "Required": false + }, + { + "ROS": "OssObjectName", + "Terraform": null, + "Required": false + }, + { + "ROS": "SourceCode", + "Terraform": null, + "Required": false + }, + { + "ROS": "ZipFile", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": null, + "Terraform": "code_checksum", + "Required": false + }, + { + "ROS": "Cpu", + "Terraform": "cpu", + "Required": false + }, + { + "ROS": "CustomContainerConfig", + "Terraform": "custom_container_config", + "Required": false + }, + { + "ROS": "CustomDNS", + "Terraform": "custom_dns", + "Required": false, + "Properties": [ + { + "ROS": "DnsOptions", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "NameServers", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "Searches", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + } + ] + }, + { + "ROS": "CustomHealthCheckConfig", + "Terraform": "custom_health_check_config", + "Required": false, + "Properties": [ + { + "ROS": "FailureThreshold", + "Terraform": null, + "Required": false + }, + { + "ROS": "HttpGetUrl", + "Terraform": null, + "Required": false + }, + { + "ROS": "InitialDelaySeconds", + "Terraform": null, + "Required": false + }, + { + "ROS": "PeriodSeconds", + "Terraform": null, + "Required": false + }, + { + "ROS": "SuccessThreshold", + "Terraform": null, + "Required": false + }, + { + "ROS": "TimeoutSeconds", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "CustomRuntimeConfig", + "Terraform": "custom_runtime_config", + "Required": false, + "Properties": [ + { + "ROS": "Args", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "Command", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + } + ] + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "DiskSize", + "Terraform": "disk_size", + "Required": false + }, + { + "ROS": "EnvironmentVariables", + "Terraform": "environment_variables", + "Required": false + }, + { + "ROS": null, + "Terraform": "filename", + "Required": false + }, + { + "ROS": "FunctionName", + "Terraform": "function_name", + "Required": false + }, + { + "ROS": "GpuMemorySize", + "Terraform": "gpu_memory_size", + "Required": false + }, + { + "ROS": "Handler", + "Terraform": "handler", + "Required": true + }, + { + "ROS": "InitializationTimeout", + "Terraform": "initialization_timeout", + "Required": false + }, + { + "ROS": "Initializer", + "Terraform": "initializer", + "Required": false + }, + { + "ROS": "InstanceConcurrency", + "Terraform": "instance_concurrency", + "Required": false + }, + { + "ROS": "InstanceLifecycleConfig", + "Terraform": "instance_lifecycle_config", + "Required": false, + "Properties": [ + { + "ROS": "PreFreeze", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Handler", + "Terraform": null, + "Required": false + }, + { + "ROS": "Timeout", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "PreStop", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Handler", + "Terraform": null, + "Required": false + }, + { + "ROS": "Timeout", + "Terraform": null, + "Required": false + } + ] + } + ] + }, + { + "ROS": "InstanceSoftConcurrency", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceType", + "Terraform": "instance_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "layers", + "Required": false + }, + { + "ROS": "MemorySize", + "Terraform": "memory_size", + "Required": false + }, + { + "ROS": "FunctionName", + "Terraform": "name", + "Required": true + }, + { + "ROS": "FunctionName", + "Terraform": "name_prefix", + "Required": false + }, + { + "ROS": null, + "Terraform": "oss_bucket", + "Required": false + }, + { + "ROS": null, + "Terraform": "oss_key", + "Required": false + }, + { + "ROS": "Runtime", + "Terraform": "runtime", + "Required": true + }, + { + "ROS": "ServiceName", + "Terraform": "service", + "Required": true + }, + { + "ROS": "ServiceName", + "Terraform": "service_name", + "Required": false + }, + { + "ROS": "Timeout", + "Terraform": "timeout", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "ARN", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "FunctionId", + "Terraform": "function_id" + }, + { + "ROS": "FunctionName", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "last_modified" + }, + { + "ROS": "ServiceId", + "Terraform": null + }, + { + "ROS": "ServiceName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::FC::FunctionInvoker", + "Terraform": null + }, + "ProductCode": "fc", + "Name": { + "zh": "FC执行函数", + "en": "Invoke Function in Function Compute" + }, + "Properties": [ + { + "ROS": "Async", + "Terraform": null, + "Required": false + }, + { + "ROS": "CheckError", + "Terraform": null, + "Required": false + }, + { + "ROS": "Event", + "Terraform": null, + "Required": false + }, + { + "ROS": "ExecuteVersion", + "Terraform": null, + "Required": false + }, + { + "ROS": "FunctionName", + "Terraform": null, + "Required": true + }, + { + "ROS": "Qualifier", + "Terraform": null, + "Required": false + }, + { + "ROS": "ServiceName", + "Terraform": null, + "Required": true + }, + { + "ROS": "ServiceRegionId", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Result", + "Terraform": null + }, + { + "ROS": "ResultType", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::FC::Layer", + "Terraform": null + }, + "ProductCode": "fc", + "Name": { + "zh": "FC层", + "en": "Layer of Function Compute" + }, + "Properties": [ + { + "ROS": "Code", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "OssBucketName", + "Terraform": null, + "Required": false + }, + { + "ROS": "OssObjectName", + "Terraform": null, + "Required": false + }, + { + "ROS": "ZipFile", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "CompatibleRuntime", + "Terraform": null, + "Required": true, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "LayerName", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": "LayerName", + "Terraform": null + }, + { + "ROS": "Version", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::FC::ProvisionConfig", + "Terraform": null + }, + "ProductCode": "fc", + "Name": { + "zh": "FC预留实例", + "en": "Function Compute Provisioned Instance" + }, + "Properties": [ + { + "ROS": "FunctionName", + "Terraform": null, + "Required": true + }, + { + "ROS": "Qualifier", + "Terraform": null, + "Required": true + }, + { + "ROS": "ServiceName", + "Terraform": null, + "Required": true + }, + { + "ROS": "Target", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "FunctionName", + "Terraform": null + }, + { + "ROS": "Qualifier", + "Terraform": null + }, + { + "ROS": "Resource", + "Terraform": null + }, + { + "ROS": "ServiceName", + "Terraform": null + }, + { + "ROS": "Target", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::FC::Service", + "Terraform": "alicloud_fc_service" + }, + "ProductCode": "fc", + "Name": { + "zh": "FC服务", + "en": "Service in Function Compute" + }, + "Properties": [ + { + "ROS": "DeletionForce", + "Terraform": null, + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "InternetAccess", + "Terraform": "internet_access", + "Required": false + }, + { + "ROS": "LogConfig", + "Terraform": "log_config", + "Required": false, + "Properties": [ + { + "ROS": "Logstore", + "Terraform": "logstore", + "Required": false + }, + { + "ROS": "Project", + "Terraform": "project", + "Required": false + } + ] + }, + { + "ROS": "ServiceName", + "Terraform": "name", + "Required": true + }, + { + "ROS": "ServiceName", + "Terraform": "name_prefix", + "Required": false + }, + { + "ROS": "NasConfig", + "Terraform": "nas_config", + "Required": false + }, + { + "ROS": "OssMountConfig", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "MountPoints", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "BucketName", + "Terraform": null, + "Required": true + }, + { + "ROS": "BucketPath", + "Terraform": null, + "Required": true + }, + { + "ROS": "EndPoint", + "Terraform": null, + "Required": true + }, + { + "ROS": "MountDir", + "Terraform": null, + "Required": true + }, + { + "ROS": "ReadOnly", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + } + ] + }, + { + "ROS": null, + "Terraform": "publish", + "Required": false + }, + { + "ROS": "Role", + "Terraform": "role", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "TracingConfig", + "Terraform": "tracing_config", + "Required": false + }, + { + "ROS": "VpcBindings", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "VpcConfig", + "Terraform": "vpc_config", + "Required": false, + "Properties": [ + { + "ROS": "SecurityGroupId", + "Terraform": "security_group_id", + "Required": true + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "Required": true + }, + { + "ROS": null, + "Terraform": "vswitch_ids", + "Required": false + } + ] + } + ], + "Attributes": [ + { + "ROS": "ServiceId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "InternetAccess", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "last_modified" + }, + { + "ROS": "LogProject", + "Terraform": null + }, + { + "ROS": "Logstore", + "Terraform": null + }, + { + "ROS": "Role", + "Terraform": null + }, + { + "ROS": "ServiceId", + "Terraform": "service_id" + }, + { + "ROS": "ServiceName", + "Terraform": null + }, + { + "ROS": "Tags", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "version" + }, + { + "ROS": "VpcId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::FC::Trigger", + "Terraform": "alicloud_fc_trigger" + }, + "ProductCode": "fc", + "Name": { + "zh": "FC触发函数执行", + "en": "Trigger Function in Function Compute" + }, + "Properties": [ + { + "ROS": "TriggerConfig", + "Terraform": "config", + "Required": true + }, + { + "ROS": null, + "Terraform": "config_mns", + "Required": false + }, + { + "ROS": "FunctionName", + "Terraform": "function", + "Required": true + }, + { + "ROS": "TriggerName", + "Terraform": "name", + "Required": true + }, + { + "ROS": "TriggerName", + "Terraform": "name_prefix", + "Required": false + }, + { + "ROS": "Qualifier", + "Terraform": null, + "Required": false + }, + { + "ROS": "InvocationRole", + "Terraform": "role", + "Required": false + }, + { + "ROS": "ServiceName", + "Terraform": "service", + "Required": true + }, + { + "ROS": "SourceArn", + "Terraform": "source_arn", + "Required": false + }, + { + "ROS": "TriggerType", + "Terraform": "type", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "FunctionName", + "Terraform": null + }, + { + "ROS": "TriggerId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "last_modified" + }, + { + "ROS": "ServiceName", + "Terraform": null + }, + { + "ROS": "TriggerId", + "Terraform": "trigger_id" + }, + { + "ROS": "TriggerName", + "Terraform": null + }, + { + "ROS": "UrlInternet", + "Terraform": null + }, + { + "ROS": "UrlIntranet", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::FC::Version", + "Terraform": null + }, + "ProductCode": "fc", + "Name": { + "zh": "FC版本", + "en": "Version in Function Compute" + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "ServiceName", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "ServiceName", + "Terraform": null + }, + { + "ROS": "VersionId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::FNF::Flow", + "Terraform": "alicloud_fnf_flow" + }, + "ProductCode": "fnf", + "Name": { + "zh": "FNF Flow", + "en": "CloudFlow Flow" + }, + "Properties": [ + { + "ROS": "Definition", + "Terraform": "definition", + "Required": true + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "ExecutionMode", + "Terraform": null, + "Required": false + }, + { + "ROS": "ExternalStorageLocation", + "Terraform": null, + "Required": false + }, + { + "ROS": "Name", + "Terraform": "name", + "Required": true + }, + { + "ROS": "RequestId", + "Terraform": null, + "Required": false + }, + { + "ROS": "RoleArn", + "Terraform": "role_arn", + "Required": false + }, + { + "ROS": null, + "Terraform": "type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "CreatedTime", + "Terraform": null + }, + { + "ROS": "Id", + "Terraform": "flow_id" + }, + { + "ROS": "Name", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "LastModifiedTime", + "Terraform": "last_modified_time" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::FNF::Schedule", + "Terraform": "alicloud_fnf_schedule" + }, + "ProductCode": "fnf", + "Name": { + "zh": "FNF Schedule", + "en": "CloudFlow Schedule" + }, + "Properties": [ + { + "ROS": "CronExpression", + "Terraform": "cron_expression", + "Required": true + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "Enable", + "Terraform": "enable", + "Required": false + }, + { + "ROS": "FlowName", + "Terraform": "flow_name", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::FNF::Flow" + } + ] + }, + { + "ROS": "Payload", + "Terraform": "payload", + "Required": false + }, + { + "ROS": "ScheduleName", + "Terraform": "schedule_name", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "FlowName", + "Terraform": null + }, + { + "ROS": "ScheduleId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "last_modified_time" + }, + { + "ROS": "ScheduleId", + "Terraform": "schedule_id" + }, + { + "ROS": "ScheduleName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::FOAS::Cluster", + "Terraform": null + }, + "ProductCode": "sc", + "Name": { + "zh": "FOAS Cluster", + "en": "Alibaba Cloud Realtime Compute Cluster" + }, + "Properties": [ + { + "ROS": "ClusterName", + "Terraform": null, + "Required": true + }, + { + "ROS": "Description", + "Terraform": null, + "Required": true + }, + { + "ROS": "Order", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "MasterNumber", + "Terraform": null, + "Required": false + }, + { + "ROS": "MasterSpec", + "Terraform": null, + "Required": true + }, + { + "ROS": "PayModel", + "Terraform": null, + "Required": false + }, + { + "ROS": "Period", + "Terraform": null, + "Required": false + }, + { + "ROS": "SlaveNumber", + "Terraform": null, + "Required": false + }, + { + "ROS": "SlaveSpec", + "Terraform": null, + "Required": true + } + ] + }, + { + "ROS": "OrderId", + "Terraform": null, + "Required": false + }, + { + "ROS": "OssBucket", + "Terraform": null, + "Required": true + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Attributes": [ + { + "ROS": "ClusterId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "EngineVersions", + "Terraform": null + }, + { + "ROS": "MasterInstanceInfos", + "Terraform": null + }, + { + "ROS": "OrderId", + "Terraform": null + }, + { + "ROS": "SecurityGroupId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "SlaveInstanceInfos", + "Terraform": null + }, + { + "ROS": "State", + "Terraform": null + }, + { + "ROS": "VSwitchIds", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::FOAS::Project", + "Terraform": null + }, + "ProductCode": "sc", + "Name": { + "zh": "FOAS Project", + "en": "Alibaba Cloud Realtime Compute Project" + }, + "Properties": [ + { + "ROS": "ClusterId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::FOAS::Cluster" + } + ] + }, + { + "ROS": "DeployType", + "Terraform": null, + "Required": true + }, + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "ManagerIds", + "Terraform": null, + "Required": true + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "OrderId", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "State", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::Flink::Instance", + "Terraform": null + }, + "ProductCode": "sc", + "Name": { + "zh": "Flink实例", + "en": "Realtime Compute for Apache Flink Instance" + }, + "Properties": [ + { + "ROS": "AutoRenew", + "Terraform": null, + "Required": false + }, + { + "ROS": "Bucket", + "Terraform": null, + "Required": true + }, + { + "ROS": "ChargeType", + "Terraform": null, + "Required": true + }, + { + "ROS": "Duration", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceName", + "Terraform": null, + "Required": true + }, + { + "ROS": "PricingCycle", + "Terraform": null, + "Required": false + }, + { + "ROS": "PromotionCode", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceSpec", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Cpu", + "Terraform": null, + "Required": false + }, + { + "ROS": "MemoryGB", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "UsePromotionCode", + "Terraform": null, + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchIds", + "Terraform": null, + "Required": true + }, + { + "ROS": "ZoneId", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "InstanceId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "OrderId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::Flink::Namespace", + "Terraform": null + }, + "ProductCode": "sc", + "Name": { + "zh": "Flink项目空间", + "en": "Realtime Compute for Apache Flink Namespace" + }, + "Properties": [ + { + "ROS": "InstanceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::Flink::Instance" + } + ] + }, + { + "ROS": "Namespace", + "Terraform": null, + "Required": true + }, + { + "ROS": "ResourceSpec", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Cpu", + "Terraform": null, + "Required": false + }, + { + "ROS": "MemoryGB", + "Terraform": null, + "Required": false + } + ] + } + ], + "Attributes": [ + { + "ROS": "InstanceId", + "Terraform": null + }, + { + "ROS": "Namespace", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::GA::Accelerator", + "Terraform": "alicloud_ga_accelerator" + }, + "ProductCode": "ga", + "Name": { + "zh": "全球加速实例", + "en": "GA Instance" + }, + "Properties": [ + { + "ROS": "AcceleratorName", + "Terraform": "accelerator_name", + "Required": false + }, + { + "ROS": "AutoPay", + "Terraform": null, + "Required": false + }, + { + "ROS": "AutoRenewDuration", + "Terraform": "auto_renew_duration", + "Required": false + }, + { + "ROS": "AutoUseCoupon", + "Terraform": "auto_use_coupon", + "Required": false + }, + { + "ROS": "BandwidthBillingType", + "Terraform": "bandwidth_billing_type", + "Required": false + }, + { + "ROS": "CrossBorderMode", + "Terraform": "cross_border_mode", + "Required": false + }, + { + "ROS": "CrossBorderStatus", + "Terraform": "cross_border_status", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "Duration", + "Terraform": "duration", + "Required": false + }, + { + "ROS": "EnableCrossBorder", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceChargeType", + "Terraform": null, + "Required": false + }, + { + "ROS": "IpSetConfig", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "AccessMode", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "PaymentType", + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": "PricingCycle", + "Terraform": "pricing_cycle", + "Required": false + }, + { + "ROS": "PromotionOptionNo", + "Terraform": "promotion_option_no", + "Required": false + }, + { + "ROS": "RenewalStatus", + "Terraform": "renewal_status", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "Spec", + "Terraform": "spec", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "AcceleratorName", + "Terraform": null + }, + { + "ROS": "AutoPay", + "Terraform": null + }, + { + "ROS": "AutoUseCoupon", + "Terraform": null + }, + { + "ROS": "DnsName", + "Terraform": null + }, + { + "ROS": "Duration", + "Terraform": null + }, + { + "ROS": "AcceleratorId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "OrderId", + "Terraform": null + }, + { + "ROS": "PaymentType", + "Terraform": null + }, + { + "ROS": "PricingCycle", + "Terraform": null + }, + { + "ROS": "Spec", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::GA::Acl", + "Terraform": "alicloud_ga_acl" + }, + "ProductCode": "ga", + "Name": { + "zh": "GA Acl", + "en": "GA ACL" + }, + "Properties": [ + { + "ROS": "AclEntries", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Entry", + "Terraform": null, + "Required": false + }, + { + "ROS": "EntryDescription", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "AclName", + "Terraform": "acl_name", + "Required": false + }, + { + "ROS": "AddressIPVersion", + "Terraform": "address_ip_version", + "Required": false + }, + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "AclEntries", + "Terraform": null + }, + { + "ROS": "AclName", + "Terraform": null + }, + { + "ROS": "AddressIPVersion", + "Terraform": null + }, + { + "ROS": "AclId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "ResourceGroupId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "Tags", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::GA::AclsListenerAssociation", + "Terraform": null + }, + "MainResourceType": { + "ResourceType": "ROS/ALIYUN::GA::Acl", + "RefProperty": "ROS/AclId" + }, + "ProductCode": "ga", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "AclIds", + "Terraform": null, + "Required": true, + "Properties": {}, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GA::Acl" + } + ], + "Type": "list" + }, + { + "ROS": "AclType", + "Terraform": null, + "Required": true + }, + { + "ROS": "ListenerId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GA::Listener" + } + ] + } + ], + "Attributes": [ + { + "ROS": "AclIds", + "Terraform": null + }, + { + "ROS": "ListenerId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::GA::ApplicationMonitor", + "Terraform": null + }, + "ProductCode": "ga", + "Name": { + "zh": "GA ApplicationMonitor", + "en": "GA Application Monitor" + }, + "Properties": [ + { + "ROS": "AcceleratorId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GA::Accelerator" + } + ] + }, + { + "ROS": "Address", + "Terraform": null, + "Required": true + }, + { + "ROS": "DetectEnable", + "Terraform": null, + "Required": false + }, + { + "ROS": "DetectThreshold", + "Terraform": null, + "Required": false + }, + { + "ROS": "DetectTimes", + "Terraform": null, + "Required": false + }, + { + "ROS": "ListenerId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GA::Listener" + } + ] + }, + { + "ROS": "OptionsJson", + "Terraform": null, + "Required": false + }, + { + "ROS": "SilenceTime", + "Terraform": null, + "Required": false + }, + { + "ROS": "TaskName", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "TaskId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::GA::BandwidthPackage", + "Terraform": "alicloud_ga_bandwidth_package" + }, + "ProductCode": "ga", + "Name": { + "zh": "全球加速带宽包", + "en": "GA Bandwidth Plan" + }, + "Properties": [ + { + "ROS": "AutoPay", + "Terraform": "auto_pay", + "Required": false + }, + { + "ROS": null, + "Terraform": "auto_renew_duration", + "Required": false + }, + { + "ROS": "AutoUseCoupon", + "Terraform": "auto_use_coupon", + "Required": false + }, + { + "ROS": "Bandwidth", + "Terraform": "bandwidth", + "Required": true + }, + { + "ROS": null, + "Terraform": "bandwidth_package_name", + "Required": false + }, + { + "ROS": "BandwidthType", + "Terraform": "bandwidth_type", + "Required": false + }, + { + "ROS": "BillingType", + "Terraform": "billing_type", + "Required": false + }, + { + "ROS": "CbnGeographicRegionIdA", + "Terraform": "cbn_geographic_region_ida", + "Required": false + }, + { + "ROS": "CbnGeographicRegionIdB", + "Terraform": "cbn_geographic_region_idb", + "Required": false + }, + { + "ROS": "ChargeType", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": "Duration", + "Terraform": "duration", + "Required": false + }, + { + "ROS": null, + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": "PricingCycle", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "promotion_option_no", + "Required": false + }, + { + "ROS": "Ratio", + "Terraform": "ratio", + "Required": false + }, + { + "ROS": null, + "Terraform": "renewal_status", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": "Type", + "Terraform": "type", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "AutoPay", + "Terraform": null + }, + { + "ROS": "AutoUseCoupon", + "Terraform": null + }, + { + "ROS": "Bandwidth", + "Terraform": null + }, + { + "ROS": "BandwidthPackageName", + "Terraform": null + }, + { + "ROS": "BandwidthType", + "Terraform": null + }, + { + "ROS": "BillingType", + "Terraform": null + }, + { + "ROS": "CbnGeographicRegionIdA", + "Terraform": null + }, + { + "ROS": "CbnGeographicRegionIdB", + "Terraform": null + }, + { + "ROS": "ChargeType", + "Terraform": null + }, + { + "ROS": "BandwidthPackageId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "PaymentType", + "Terraform": null + }, + { + "ROS": "Ratio", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "Type", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::GA::BandwidthPackageAcceleratorAddition", + "Terraform": "alicloud_ga_bandwidth_package_attachment" + }, + "MainResourceType": { + "ResourceType": "ROS/ALIYUN::GA::BandwidthPackage", + "RefProperty": "ROS/BandwidthPackageId" + }, + "ProductCode": "ga", + "Name": { + "zh": "绑定全球加速带宽包", + "en": "Associate GA Bandwidth Plan" + }, + "Properties": [ + { + "ROS": "AcceleratorId", + "Terraform": "accelerator_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GA::Accelerator" + } + ] + }, + { + "ROS": "BandwidthPackageId", + "Terraform": "bandwidth_package_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GA::BandwidthPackage" + } + ] + } + ], + "Attributes": [ + { + "ROS": "AcceleratorId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "accelerators" + }, + { + "ROS": "BandwidthPackageId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::GA::BasicAccelerateIp", + "Terraform": "alicloud_ga_basic_accelerate_ip" + }, + "ProductCode": "ga", + "Name": { + "zh": "GA BasicAccelerateIp", + "en": "Basic GA Instance IP" + }, + "Properties": [ + { + "ROS": "AcceleratorId", + "Terraform": "accelerator_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GA::Accelerator" + } + ] + }, + { + "ROS": "IpSetId", + "Terraform": "ip_set_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GA::BasicIpSet" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "accelerate_ip_address" + }, + { + "ROS": "AccelerateIpId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::GA::BasicAccelerator", + "Terraform": "alicloud_ga_basic_accelerator" + }, + "ProductCode": "ga", + "Name": { + "zh": "GA BasicAccelerator", + "en": "Basic GA Instance" + }, + "Properties": [ + { + "ROS": "AutoPay", + "Terraform": "auto_pay", + "Required": false + }, + { + "ROS": "AutoRenew", + "Terraform": "auto_renew", + "Required": false + }, + { + "ROS": "AutoRenewDuration", + "Terraform": "auto_renew_duration", + "Required": false + }, + { + "ROS": "AutoUseCoupon", + "Terraform": "auto_use_coupon", + "Required": false + }, + { + "ROS": "BandwidthBillingType", + "Terraform": "bandwidth_billing_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "basic_accelerator_name", + "Required": false + }, + { + "ROS": "ChargeType", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "cross_border_status", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": "Duration", + "Terraform": "duration", + "Required": false + }, + { + "ROS": null, + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": "PricingCycle", + "Terraform": "pricing_cycle", + "Required": false + }, + { + "ROS": "PromotionOptionNo", + "Terraform": "promotion_option_no", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "AcceleratorId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::GA::BasicAcceleratorIpEndpointRelation", + "Terraform": null + }, + "ProductCode": "ga", + "Name": { + "zh": "GA 加速IP与终端节点绑定", + "en": "Accelerated IP and Endpoint Association" + }, + "Properties": [ + { + "ROS": "AccelerateIpId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GA::BasicAccelerateIp" + } + ] + }, + { + "ROS": "AcceleratorId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GA::Accelerator" + } + ] + }, + { + "ROS": "EndpointId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GA::BasicEndpoint" + } + ] + } + ], + "Attributes": [ + { + "ROS": "AccelerateIpId", + "Terraform": null + }, + { + "ROS": "AcceleratorId", + "Terraform": null + }, + { + "ROS": "EndpointId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::GA::BasicEndpoint", + "Terraform": "alicloud_ga_basic_endpoint" + }, + "ProductCode": "ga", + "Name": { + "zh": "GA BasicEndpoint", + "en": "GA Basic Endpoint" + }, + "Properties": [ + { + "ROS": "AcceleratorId", + "Terraform": "accelerator_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GA::Accelerator" + } + ] + }, + { + "ROS": null, + "Terraform": "basic_endpoint_name", + "Required": false + }, + { + "ROS": "EndpointAddress", + "Terraform": "endpoint_address", + "Required": true + }, + { + "ROS": "EndpointGroupId", + "Terraform": "endpoint_group_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GA::EndpointGroup" + } + ] + }, + { + "ROS": "EndpointSubAddress", + "Terraform": "endpoint_sub_address", + "Required": false + }, + { + "ROS": "EndpointSubAddressType", + "Terraform": "endpoint_sub_address_type", + "Required": false + }, + { + "ROS": "EndpointType", + "Terraform": "endpoint_type", + "Required": false + }, + { + "ROS": "EndpointZoneId", + "Terraform": "endpoint_zone_id", + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "EndpointId", + "Terraform": "endpoint_id" + }, + { + "ROS": "EndpointId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::GA::BasicEndpointGroup", + "Terraform": "alicloud_ga_basic_endpoint_group" + }, + "ProductCode": "ga", + "Name": { + "zh": "GA BasicEndpointGroup", + "en": "GA Basic Endpoint Group" + }, + "Properties": [ + { + "ROS": "AcceleratorId", + "Terraform": "accelerator_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GA::Accelerator" + } + ] + }, + { + "ROS": null, + "Terraform": "basic_endpoint_group_name", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "EndpointAddress", + "Terraform": "endpoint_address", + "Required": false + }, + { + "ROS": "EndpointGroupRegion", + "Terraform": "endpoint_group_region", + "Required": true + }, + { + "ROS": "EndpointSubAddress", + "Terraform": "endpoint_sub_address", + "Required": false + }, + { + "ROS": "EndpointType", + "Terraform": "endpoint_type", + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "EndpointGroupId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::GA::BasicIpSet", + "Terraform": "alicloud_ga_basic_ip_set" + }, + "ProductCode": "ga", + "Name": { + "zh": "GA BasicIpSet", + "en": "GA Basic IP Set" + }, + "Properties": [ + { + "ROS": "AccelerateRegionId", + "Terraform": "accelerate_region_id", + "Required": false + }, + { + "ROS": "AcceleratorId", + "Terraform": "accelerator_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GA::Accelerator" + } + ] + }, + { + "ROS": "Bandwidth", + "Terraform": "bandwidth", + "Required": false + }, + { + "ROS": "IspType", + "Terraform": "isp_type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "IpSetId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::GA::Domain", + "Terraform": "alicloud_ga_domain" + }, + "ProductCode": "ga", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "AcceleratorIds.0", + "Terraform": "accelerator_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GA::Accelerator" + } + ] + }, + { + "ROS": "Domain", + "Terraform": "domain", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "Domain", + "Terraform": null + }, + { + "ROS": "AcceleratorIds.0", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::GA::EndpointGroup", + "Terraform": "alicloud_ga_endpoint_group" + }, + "ProductCode": "ga", + "Name": { + "zh": "全球加速终端节点组", + "en": "GA Endpoint Group" + }, + "Properties": [ + { + "ROS": "AcceleratorId", + "Terraform": "accelerator_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GA::Accelerator" + } + ] + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "EndpointConfigurations", + "Terraform": "endpoint_configurations", + "Required": true, + "Properties": [ + { + "ROS": null, + "Terraform": "enable_clientip_preservation", + "Required": false + }, + { + "ROS": "EnableProxyProtocol", + "Terraform": "enable_proxy_protocol", + "Required": false + }, + { + "ROS": "Endpoint", + "Terraform": "endpoint", + "Required": true + }, + { + "ROS": null, + "Terraform": "sub_address", + "Required": false + }, + { + "ROS": "Type", + "Terraform": "type", + "Required": true + }, + { + "ROS": "Weight", + "Terraform": "weight", + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "EndpointGroupRegion", + "Terraform": "endpoint_group_region", + "Required": true + }, + { + "ROS": "EndpointGroupType", + "Terraform": "endpoint_group_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "endpoint_protocol_version", + "Required": false + }, + { + "ROS": "EndpointRequestProtocol", + "Terraform": "endpoint_request_protocol", + "Required": false + }, + { + "ROS": "HealthCheckEnabled", + "Terraform": "health_check_enabled", + "Required": false + }, + { + "ROS": "HealthCheckIntervalSeconds", + "Terraform": "health_check_interval_seconds", + "Required": false + }, + { + "ROS": "HealthCheckPath", + "Terraform": "health_check_path", + "Required": false + }, + { + "ROS": "HealthCheckPort", + "Terraform": "health_check_port", + "Required": false + }, + { + "ROS": "HealthCheckProtocol", + "Terraform": "health_check_protocol", + "Required": false + }, + { + "ROS": "ListenerId", + "Terraform": "listener_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GA::Listener" + } + ] + }, + { + "ROS": "Name", + "Terraform": "name", + "Required": false + }, + { + "ROS": null, + "Terraform": "port_overrides", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": "ThresholdCount", + "Terraform": "threshold_count", + "Required": false + }, + { + "ROS": "TrafficPercentage", + "Terraform": "traffic_percentage", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "endpoint_group_ip_list" + }, + { + "ROS": "EndpointGroupId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::GA::EndpointGroups", + "Terraform": null + }, + "ProductCode": "ga", + "Name": { + "zh": "GA EndpointGroups", + "en": "GA Endpoint Groups" + }, + "Properties": [ + { + "ROS": "AcceleratorId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GA::Accelerator" + } + ] + }, + { + "ROS": "EndpointGroupConfigurations", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "EnableClientIPPreservationProxyProtocol", + "Terraform": null, + "Required": false + }, + { + "ROS": "EnableClientIPPreservationToa", + "Terraform": null, + "Required": false + }, + { + "ROS": "EndpointConfigurations", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Endpoint", + "Terraform": null, + "Required": true + }, + { + "ROS": "SubAddress", + "Terraform": null, + "Required": false + }, + { + "ROS": "Type", + "Terraform": null, + "Required": true + }, + { + "ROS": "Weight", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "EndpointGroupDescription", + "Terraform": null, + "Required": false + }, + { + "ROS": "EndpointGroupName", + "Terraform": null, + "Required": false + }, + { + "ROS": "EndpointGroupRegion", + "Terraform": null, + "Required": true + }, + { + "ROS": "EndpointGroupType", + "Terraform": null, + "Required": false + }, + { + "ROS": "EndpointRequestProtocol", + "Terraform": null, + "Required": false + }, + { + "ROS": "HealthCheckEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "HealthCheckIntervalSeconds", + "Terraform": null, + "Required": false + }, + { + "ROS": "HealthCheckPath", + "Terraform": null, + "Required": false + }, + { + "ROS": "HealthCheckPort", + "Terraform": null, + "Required": false + }, + { + "ROS": "HealthCheckProtocol", + "Terraform": null, + "Required": false + }, + { + "ROS": "PortOverrides", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "EndpointPort", + "Terraform": null, + "Required": true + }, + { + "ROS": "ListenerPort", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": false + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "ThresholdCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "TrafficPercentage", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "ListenerId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GA::Listener" + } + ] + } + ], + "Attributes": [ + { + "ROS": "EndpointGroupIds", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::GA::ForwardingRules", + "Terraform": "alicloud_ga_forwarding_rule" + }, + "ProductCode": "ga", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "AcceleratorId", + "Terraform": "accelerator_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GA::Accelerator" + } + ] + }, + { + "ROS": null, + "Terraform": "forwarding_rule_name", + "Required": false + }, + { + "ROS": "ForwardingRules", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "ForwardingRuleName", + "Terraform": null, + "Required": false + }, + { + "ROS": "Priority", + "Terraform": null, + "Required": false + }, + { + "ROS": "RuleActions", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "Order", + "Terraform": null, + "Required": true + }, + { + "ROS": "RuleActionType", + "Terraform": null, + "Required": true + }, + { + "ROS": "RuleActionValue", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "RuleConditions", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "RuleConditionType", + "Terraform": null, + "Required": false + }, + { + "ROS": "RuleConditionValue", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "RuleDirection", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "ListenerId", + "Terraform": "listener_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GA::Listener" + } + ] + }, + { + "ROS": null, + "Terraform": "priority", + "Required": false + }, + { + "ROS": null, + "Terraform": "rule_actions", + "Required": false + }, + { + "ROS": null, + "Terraform": "rule_conditions", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "forwarding_rule_id" + }, + { + "ROS": "ForwardingRuleIds", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "forwarding_rule_status" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::GA::IpSets", + "Terraform": "alicloud_ga_ip_set" + }, + "ProductCode": "ga", + "Name": { + "zh": "全球加速地域", + "en": "GA Acceleration Regions" + }, + "Properties": [ + { + "ROS": "AccelerateRegion.0.AccelerateRegionId", + "Terraform": "accelerate_region_id", + "Required": false + }, + { + "ROS": "AcceleratorId", + "Terraform": "accelerator_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GA::Accelerator" + } + ] + }, + { + "ROS": "AccelerateRegion.0.Bandwidth", + "Terraform": "bandwidth", + "Required": false + }, + { + "ROS": "AccelerateRegion.0.IpVersion", + "Terraform": "ip_version", + "Required": false + }, + { + "ROS": null, + "Terraform": "isp_type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "AccelerateRegionIds", + "Terraform": null + }, + { + "ROS": "IpSetIds.0", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "ip_address_list" + }, + { + "ROS": "IpVersions", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::GA::Listener", + "Terraform": "alicloud_ga_listener" + }, + "ProductCode": "ga", + "Name": { + "zh": "全球加速监听", + "en": "GA Listener" + }, + "Properties": [ + { + "ROS": "AcceleratorId", + "Terraform": "accelerator_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GA::Accelerator" + } + ] + }, + { + "ROS": "Certificates", + "Terraform": "certificates", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GA::Accelerator" + } + ], + "Properties": [ + { + "ROS": "Id", + "Terraform": "id", + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "ClientAffinity", + "Terraform": "client_affinity", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "forwarded_for_config", + "Required": false + }, + { + "ROS": null, + "Terraform": "http_version", + "Required": false + }, + { + "ROS": null, + "Terraform": "idle_timeout", + "Required": false + }, + { + "ROS": null, + "Terraform": "listener_type", + "Required": false + }, + { + "ROS": "Name", + "Terraform": "name", + "Required": false + }, + { + "ROS": "PortRanges", + "Terraform": "port_ranges", + "Required": true, + "Properties": [ + { + "ROS": "FromPort", + "Terraform": "from_port", + "Required": true + }, + { + "ROS": "ToPort", + "Terraform": "to_port", + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "Protocol", + "Terraform": "protocol", + "Required": true + }, + { + "ROS": "ProxyProtocol", + "Terraform": "proxy_protocol", + "Required": false + }, + { + "ROS": null, + "Terraform": "request_timeout", + "Required": false + }, + { + "ROS": "SecurityPolicyId", + "Terraform": "security_policy_id", + "Required": false + }, + { + "ROS": "XForwardedForConfig", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "XForwardedForGaApEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "XForwardedForGaIdEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "XForwardedForPortEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "XForwardedForProtoEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "XRealIpEnabled", + "Terraform": null, + "Required": false + } + ] + } + ], + "Attributes": [ + { + "ROS": "ListenerId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::GPDB::Account", + "Terraform": "alicloud_gpdb_account" + }, + "ProductCode": "gpdb", + "Name": { + "zh": "GPDB数据库账号", + "en": "AnalyticDB for PostgreSQL Database Account" + }, + "Properties": [ + { + "ROS": "AccountDescription", + "Terraform": "account_description", + "Required": false + }, + { + "ROS": "AccountName", + "Terraform": "account_name", + "Required": true + }, + { + "ROS": "AccountPassword", + "Terraform": "account_password", + "Required": true + }, + { + "ROS": null, + "Terraform": "account_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "database_name", + "Required": false + }, + { + "ROS": "DBInstanceId", + "Terraform": "db_instance_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GPDB::DBInstance" + }, + { + "ResourceType": "ROS/ALIYUN::GPDB::ElasticDBInstance" + } + ] + } + ], + "Attributes": [ + { + "ROS": "AccountName", + "Terraform": null + }, + { + "ROS": "DBInstanceId", + "Terraform": null + }, + { + "ROS": "AccountName", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::GPDB::DBInstance", + "Terraform": "alicloud_gpdb_instance" + }, + "ProductCode": "gpdb", + "Name": { + "zh": "GPDB实例", + "en": "AnalyticDB for PostgreSQL Instance" + }, + "Properties": [ + { + "ROS": "AINodeSpecInfos", + "Terraform": null, + "Required": false, + "Type": "list", + "Properties": [ + { + "ROS": "AINodeNum", + "Terraform": null, + "Required": true + }, + { + "ROS": "AINodeSpec", + "Terraform": null, + "Required": true + } + ] + }, + { + "ROS": "CreateSampleData", + "Terraform": "create_sample_data", + "Required": false + }, + { + "ROS": "DBInstanceCategory", + "Terraform": "db_instance_category", + "Required": false + }, + { + "ROS": "DBInstanceClass", + "Terraform": "db_instance_class", + "Required": false + }, + { + "ROS": "DBInstanceMode", + "Terraform": "db_instance_mode", + "Required": false + }, + { + "ROS": "DeployMode", + "Terraform": null, + "Required": false + }, + { + "ROS": "DBInstanceDescription", + "Terraform": "description", + "Required": false + }, + { + "ROS": "EncryptionKey", + "Terraform": "encryption_key", + "Required": false + }, + { + "ROS": "EncryptionType", + "Terraform": "encryption_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "engine", + "Required": false + }, + { + "ROS": "EngineVersion", + "Terraform": "engine_version", + "Required": true + }, + { + "ROS": "IdleTime", + "Terraform": null, + "Required": false + }, + { + "ROS": "DBInstanceGroupCount", + "Terraform": "instance_group_count", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_network_type", + "Required": false + }, + { + "ROS": "InstanceSpec", + "Terraform": "instance_spec", + "Required": false + }, + { + "ROS": null, + "Terraform": "ip_whitelist", + "Required": false + }, + { + "ROS": null, + "Terraform": "maintain_end_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "maintain_start_time", + "Required": false + }, + { + "ROS": "MasterCU", + "Terraform": "master_cu", + "Required": false + }, + { + "ROS": "MasterNodeNum", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "parameters", + "Required": false + }, + { + "ROS": "PayType", + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": "Period", + "Terraform": "period", + "Required": false + }, + { + "ROS": "PeriodUnit", + "Terraform": null, + "Required": false + }, + { + "ROS": "PrivateIpAddress", + "Terraform": null, + "Required": false + }, + { + "ROS": "ProdType", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "resource_management_mode", + "Required": false + }, + { + "ROS": "SecurityIPList", + "Terraform": null, + "Required": false + }, + { + "ROS": "SegDiskPerformanceLevel", + "Terraform": null, + "Required": false + }, + { + "ROS": "SegNodeNum", + "Terraform": "seg_node_num", + "Required": false + }, + { + "ROS": "SegStorageType", + "Terraform": "seg_storage_type", + "Required": false + }, + { + "ROS": "ServerlessMode", + "Terraform": null, + "Required": false + }, + { + "ROS": "ServerlessResource", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "ssl_enabled", + "Required": false + }, + { + "ROS": "StandbyVSwitchId", + "Terraform": null, + "Required": false + }, + { + "ROS": "StandbyZoneId", + "Terraform": null, + "Required": false + }, + { + "ROS": "StorageSize", + "Terraform": "storage_size", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": null, + "Terraform": "used_time", + "Required": false + }, + { + "ROS": "VectorConfigurationStatus", + "Terraform": "vector_configuration_status", + "Required": false + }, + { + "ROS": "VPCId", + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "ZoneId", + "Terraform": "zone_id", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": "ConnectionString", + "Terraform": "connection_string" + }, + { + "ROS": "DBInstanceId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "OrderId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "parameters" + }, + { + "ROS": "Port", + "Terraform": "port" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::GPDB::ElasticDBInstance", + "Terraform": null + }, + "ProductCode": "gpdb", + "Name": { + "zh": "GPDB ElasticDBInstance", + "en": "AnalyticDB for PostgreSQL Elastic Storage Instance" + }, + "Properties": [ + { + "ROS": "DBInstanceCategory", + "Terraform": null, + "Required": false + }, + { + "ROS": "DBInstanceDescription", + "Terraform": null, + "Required": false + }, + { + "ROS": "DBInstanceMode", + "Terraform": null, + "Required": false + }, + { + "ROS": "EncryptionKey", + "Terraform": null, + "Required": false + }, + { + "ROS": "EncryptionType", + "Terraform": null, + "Required": false + }, + { + "ROS": "EngineVersion", + "Terraform": null, + "Required": true + }, + { + "ROS": "InstanceSpec", + "Terraform": null, + "Required": true + }, + { + "ROS": "MasterNodeNum", + "Terraform": null, + "Required": false + }, + { + "ROS": "PayType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Period", + "Terraform": null, + "Required": false + }, + { + "ROS": "PeriodUnit", + "Terraform": null, + "Required": false + }, + { + "ROS": "PrivateIpAddress", + "Terraform": null, + "Required": false + }, + { + "ROS": "SecurityIPList", + "Terraform": null, + "Required": false + }, + { + "ROS": "SegNodeNum", + "Terraform": null, + "Required": true + }, + { + "ROS": "SegStorageType", + "Terraform": null, + "Required": true + }, + { + "ROS": "StorageSize", + "Terraform": null, + "Required": true + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "VPCId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "ZoneId", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": "ConnectionString", + "Terraform": null + }, + { + "ROS": "DBInstanceId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "OrderId", + "Terraform": null + }, + { + "ROS": "Port", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::GPDB::InstancePublicConnection", + "Terraform": null + }, + "ProductCode": "gpdb", + "Name": { + "zh": "GPDB InstancePublicConnection", + "en": "AnalyticDB for PostgreSQL Instance Public Endpoint" + }, + "Properties": [ + { + "ROS": "ConnectionStringPrefix", + "Terraform": null, + "Required": true + }, + { + "ROS": "DBInstanceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GPDB::DBInstance" + }, + { + "ResourceType": "ROS/ALIYUN::GPDB::ElasticDBInstance" + } + ] + }, + { + "ROS": "Port", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "ConnectionString", + "Terraform": null + }, + { + "ROS": "DBInstanceId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::GraphDatabase::Account", + "Terraform": null + }, + "ProductCode": "gds", + "Name": { + "zh": "GraphDatabase Account", + "en": "GDB Account" + }, + "Properties": [ + { + "ROS": "AccountDescription", + "Terraform": null, + "Required": false + }, + { + "ROS": "AccountName", + "Terraform": null, + "Required": true + }, + { + "ROS": "AccountPassword", + "Terraform": null, + "Required": true + }, + { + "ROS": "DbInstanceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GraphDatabase::DbInstance" + } + ] + } + ], + "Attributes": [ + { + "ROS": "AccountDescription", + "Terraform": null + }, + { + "ROS": "AccountName", + "Terraform": null + }, + { + "ROS": "AccountType", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::GraphDatabase::DbInstance", + "Terraform": "alicloud_graph_database_db_instance" + }, + "ProductCode": "gds", + "Name": { + "zh": "GraphDatabase DbInstance", + "en": "GraphDB Instance" + }, + "Properties": [ + { + "ROS": "BackupSetId", + "Terraform": null, + "Required": false + }, + { + "ROS": "CreateType", + "Terraform": null, + "Required": false + }, + { + "ROS": "DbInstanceCategory", + "Terraform": "db_instance_category", + "Required": true + }, + { + "ROS": "DbInstanceDescription", + "Terraform": "db_instance_description", + "Required": false + }, + { + "ROS": "DBInstanceIPArray", + "Terraform": "db_instance_ip_array", + "Required": false, + "Properties": [ + { + "ROS": "DbInstanceIpArrayName", + "Terraform": null, + "Required": false + }, + { + "ROS": "SecurityIps", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "DbInstanceNetworkType", + "Terraform": "db_instance_network_type", + "Required": true + }, + { + "ROS": "DbInstanceStorageType", + "Terraform": "db_instance_storage_type", + "Required": true + }, + { + "ROS": "DbNodeClass", + "Terraform": "db_node_class", + "Required": true + }, + { + "ROS": "DbNodeStorage", + "Terraform": "db_node_storage", + "Required": true + }, + { + "ROS": "DbVersion", + "Terraform": "db_version", + "Required": true + }, + { + "ROS": "EcsSecurityGroupRelations", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "NetworkType", + "Terraform": null, + "Required": false + }, + { + "ROS": "RegionId", + "Terraform": null, + "Required": false + }, + { + "ROS": "SecurityGroupId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + } + ], + "Type": "list" + }, + { + "ROS": "MaintainTime", + "Terraform": null, + "Required": false + }, + { + "ROS": "PaymentType", + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "RestoreType", + "Terraform": null, + "Required": false + }, + { + "ROS": "SourceDbInstanceId", + "Terraform": null, + "Required": false + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "ZoneId", + "Terraform": "zone_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "ConnectionString", + "Terraform": "connection_string" + }, + { + "ROS": "CreateTime", + "Terraform": null + }, + { + "ROS": "CurrentMinorVersion", + "Terraform": null + }, + { + "ROS": "DbInstanceCategory", + "Terraform": null + }, + { + "ROS": "DbInstanceCpu", + "Terraform": null + }, + { + "ROS": "DbInstanceDescription", + "Terraform": null + }, + { + "ROS": "DbInstanceId", + "Terraform": null + }, + { + "ROS": "DBInstanceIPArray", + "Terraform": null + }, + { + "ROS": "DbInstanceMemory", + "Terraform": null + }, + { + "ROS": "DbInstanceNetworkType", + "Terraform": null + }, + { + "ROS": "DbInstanceStorageType", + "Terraform": null + }, + { + "ROS": "DbInstanceType", + "Terraform": null + }, + { + "ROS": "DbNodeClass", + "Terraform": null + }, + { + "ROS": "DbNodeCount", + "Terraform": null + }, + { + "ROS": "DbNodeStorage", + "Terraform": null + }, + { + "ROS": "DbVersion", + "Terraform": null + }, + { + "ROS": "EcsSecurityGroupRelations", + "Terraform": null + }, + { + "ROS": "Expired", + "Terraform": null + }, + { + "ROS": "ExpireTime", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "LatestMinorVersion", + "Terraform": null + }, + { + "ROS": "LockMode", + "Terraform": null + }, + { + "ROS": "LockReason", + "Terraform": null + }, + { + "ROS": "MaintainTime", + "Terraform": null + }, + { + "ROS": "PaymentType", + "Terraform": null + }, + { + "ROS": "Port", + "Terraform": "port" + }, + { + "ROS": "PublicConnectionString", + "Terraform": null + }, + { + "ROS": "PublicPort", + "Terraform": null + }, + { + "ROS": "ReadOnlyDbInstanceIds", + "Terraform": null + }, + { + "ROS": "ResourceGroupId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "Tags", + "Terraform": null + }, + { + "ROS": "VpcId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "ZoneId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::HBR::BackupClients", + "Terraform": "alicloud_hbr_ecs_backup_client" + }, + "ProductCode": "hbr", + "Name": { + "zh": "ECS实例备份客户端", + "en": "Backup Clients on ECS Instances" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "data_proxy_setting", + "Required": false + }, + { + "ROS": "InstanceIds.0", + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "max_cpu_core", + "Required": false + }, + { + "ROS": null, + "Terraform": "max_worker", + "Required": false + }, + { + "ROS": null, + "Terraform": "proxy_host", + "Required": false + }, + { + "ROS": null, + "Terraform": "proxy_password", + "Required": false + }, + { + "ROS": null, + "Terraform": "proxy_port", + "Required": false + }, + { + "ROS": null, + "Terraform": "proxy_user", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": null, + "Terraform": "use_https", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": "ClientIds.0", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "InstanceIds", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::HBR::DbAgent", + "Terraform": null + }, + "ProductCode": "hbr", + "Name": { + "zh": "HBR数据库备份客户端", + "en": "HBR Database Backup Client" + }, + "Properties": [ + { + "ROS": "CrossAccountRoleName", + "Terraform": null, + "Required": false + }, + { + "ROS": "CrossAccountType", + "Terraform": null, + "Required": false + }, + { + "ROS": "CrossAccountUserId", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceInfo", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "AuthenticationType", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceId", + "Terraform": null, + "Required": true + }, + { + "ROS": "Password", + "Terraform": null, + "Required": false + }, + { + "ROS": "SourceType", + "Terraform": null, + "Required": true + }, + { + "ROS": "UserName", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "InstanceIds", + "Terraform": null + }, + { + "ROS": "TaskId", + "Terraform": null + }, + { + "ROS": "UniBackupInstanceDetails", + "Terraform": null + }, + { + "ROS": "UniBackupInstances", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::HBR::DbPlan", + "Terraform": null + }, + "ProductCode": "hbr", + "Name": { + "zh": "HBR备份计划", + "en": "HBR Backup Plan" + }, + "Properties": [ + { + "ROS": "ContinuousPlan", + "Terraform": null, + "Required": false + }, + { + "ROS": "CumulativePlan", + "Terraform": null, + "Required": false + }, + { + "ROS": "DbPlanName", + "Terraform": null, + "Required": true + }, + { + "ROS": "FullPlan", + "Terraform": null, + "Required": false + }, + { + "ROS": "HostUuid", + "Terraform": null, + "Required": true + }, + { + "ROS": "IncPlan", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceUuid", + "Terraform": null, + "Required": false + }, + { + "ROS": "LogPlan", + "Terraform": null, + "Required": false + }, + { + "ROS": "MaxRateLimit", + "Terraform": null, + "Required": false + }, + { + "ROS": "MaxRetrySeconds", + "Terraform": null, + "Required": false + }, + { + "ROS": "Options", + "Terraform": null, + "Required": false + }, + { + "ROS": "Source", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Entries", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + } + ] + }, + { + "ROS": "SourceType", + "Terraform": null, + "Required": true + }, + { + "ROS": "VaultId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::HBR::Vault" + } + ] + } + ], + "Attributes": [ + { + "ROS": "ContinuousPlan", + "Terraform": null + }, + { + "ROS": "ContinuousUuid", + "Terraform": null + }, + { + "ROS": "CumulativePlan", + "Terraform": null + }, + { + "ROS": "CumulativeUuid", + "Terraform": null + }, + { + "ROS": "DbPlanName", + "Terraform": null + }, + { + "ROS": "FullPlan", + "Terraform": null + }, + { + "ROS": "FullUuid", + "Terraform": null + }, + { + "ROS": "HostUuid", + "Terraform": null + }, + { + "ROS": "PlanId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "IncPlan", + "Terraform": null + }, + { + "ROS": "IncUuid", + "Terraform": null + }, + { + "ROS": "InstanceUuid", + "Terraform": null + }, + { + "ROS": "LogPlan", + "Terraform": null + }, + { + "ROS": "LogUuid", + "Terraform": null + }, + { + "ROS": "MaxRateLimit", + "Terraform": null + }, + { + "ROS": "MaxRetrySeconds", + "Terraform": null + }, + { + "ROS": "Options", + "Terraform": null + }, + { + "ROS": "PlanId", + "Terraform": null + }, + { + "ROS": "SourceType", + "Terraform": null + }, + { + "ROS": "Target", + "Terraform": null + }, + { + "ROS": "VaultId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::HBR::DbVault", + "Terraform": null + }, + "ProductCode": "hbr", + "Name": { + "zh": "HBR镜像备份仓库", + "en": "HBR Mirror Vault" + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "RetentionDays", + "Terraform": null, + "Required": true + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "VaultName", + "Terraform": null, + "Required": true + }, + { + "ROS": "VaultRegionId", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "Description", + "Terraform": null + }, + { + "ROS": "RetentionDays", + "Terraform": null + }, + { + "ROS": "VaultId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "VaultName", + "Terraform": null + }, + { + "ROS": "VaultRegionId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::HBR::RestoreJob", + "Terraform": "alicloud_hbr_restore_job" + }, + "ProductCode": "hbr", + "Name": { + "zh": "HBR恢复任务", + "en": "HBR Restore Job" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "cross_account_role_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "cross_account_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "cross_account_user_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "exclude", + "Required": false + }, + { + "ROS": null, + "Terraform": "include", + "Required": false + }, + { + "ROS": null, + "Terraform": "options", + "Required": false + }, + { + "ROS": null, + "Terraform": "ots_detail", + "Required": false + }, + { + "ROS": null, + "Terraform": "overwrite_existing", + "Required": false + }, + { + "ROS": null, + "Terraform": "restore_job_id", + "Required": false + }, + { + "ROS": "RestoreType", + "Terraform": "restore_type", + "Required": true + }, + { + "ROS": null, + "Terraform": "snapshot_hash", + "Required": false + }, + { + "ROS": "SnapshotId", + "Terraform": "snapshot_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Snapshot" + } + ] + }, + { + "ROS": "SourceClientId", + "Terraform": null, + "Required": true + }, + { + "ROS": "SourceInstanceId", + "Terraform": null, + "Required": true + }, + { + "ROS": "SourceType", + "Terraform": "source_type", + "Required": true + }, + { + "ROS": null, + "Terraform": "target_bucket", + "Required": false + }, + { + "ROS": "TargetClientId", + "Terraform": "target_client_id", + "Required": true + }, + { + "ROS": null, + "Terraform": "target_create_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "target_data_source_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "target_file_system_id", + "Required": false + }, + { + "ROS": "TargetInstanceId", + "Terraform": "target_instance_id", + "Required": true + }, + { + "ROS": null, + "Terraform": "target_instance_name", + "Required": false + }, + { + "ROS": "TargetPath", + "Terraform": "target_path", + "Required": true + }, + { + "ROS": null, + "Terraform": "target_prefix", + "Required": false + }, + { + "ROS": null, + "Terraform": "target_table_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "target_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "udm_detail", + "Required": false + }, + { + "ROS": "VaultId", + "Terraform": "vault_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::HBR::Vault" + }, + { + "ResourceType": "ROS/ALIYUN::HBR::DbVault" + } + ] + } + ], + "Attributes": [ + { + "ROS": "ErrorMessage", + "Terraform": null + }, + { + "ROS": "RestoreId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "RestoreType", + "Terraform": null + }, + { + "ROS": "SourceType", + "Terraform": null + }, + { + "ROS": "Status", + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::HBR::Vault", + "Terraform": "alicloud_hbr_vault" + }, + "ProductCode": "hbr", + "Name": { + "zh": "HBR备份仓库", + "en": "HBR Backup Vault" + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "EncryptType", + "Terraform": "encrypt_type", + "Required": false + }, + { + "ROS": "KmsKeyId", + "Terraform": "kms_key_id", + "Required": false + }, + { + "ROS": "RedundancyType", + "Terraform": "redundancy_type", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "VaultName", + "Terraform": "vault_name", + "Required": true + }, + { + "ROS": "VaultStorageClass", + "Terraform": "vault_storage_class", + "Required": false + }, + { + "ROS": "VaultType", + "Terraform": "vault_type", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "BackupPlanStatistics", + "Terraform": null + }, + { + "ROS": "BytesDone", + "Terraform": null + }, + { + "ROS": "CreateTime", + "Terraform": null + }, + { + "ROS": "Dedup", + "Terraform": null + }, + { + "ROS": "Description", + "Terraform": null + }, + { + "ROS": "VaultId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "IndexAvailable", + "Terraform": null + }, + { + "ROS": "IndexLevel", + "Terraform": null + }, + { + "ROS": "IndexUpdateTime", + "Terraform": null + }, + { + "ROS": "LatestReplicationTime", + "Terraform": null + }, + { + "ROS": "PaymentType", + "Terraform": null + }, + { + "ROS": "RedundancyType", + "Terraform": null + }, + { + "ROS": "Replication", + "Terraform": null + }, + { + "ROS": "ReplicationProgress", + "Terraform": null + }, + { + "ROS": "ReplicationSourceRegionId", + "Terraform": null + }, + { + "ROS": "ReplicationSourceVaultId", + "Terraform": null + }, + { + "ROS": "ResourceGroupId", + "Terraform": null + }, + { + "ROS": "Retention", + "Terraform": null + }, + { + "ROS": "SearchEnabled", + "Terraform": null + }, + { + "ROS": "SourceTypes", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "StorageSize", + "Terraform": null + }, + { + "ROS": "Tags", + "Terraform": null + }, + { + "ROS": "TrialInfo", + "Terraform": null + }, + { + "ROS": "UpdatedTime", + "Terraform": null + }, + { + "ROS": "VaultName", + "Terraform": null + }, + { + "ROS": "VaultStatusMessage", + "Terraform": null + }, + { + "ROS": "VaultStorageClass", + "Terraform": null + }, + { + "ROS": "VaultType", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::HBase::Cluster", + "Terraform": "alicloud_hbase_instance" + }, + "ProductCode": "hbase", + "Name": { + "zh": "HBase Cluster", + "en": "ApsaraDB for HBase Cluster" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "account", + "Required": false + }, + { + "ROS": null, + "Terraform": "auto_renew", + "Required": false + }, + { + "ROS": "AutoRenewPeriod", + "Terraform": null, + "Required": false + }, + { + "ROS": "ClusterName", + "Terraform": null, + "Required": false + }, + { + "ROS": "ColdStorageSize", + "Terraform": "cold_storage_size", + "Required": false + }, + { + "ROS": null, + "Terraform": "core_disk_size", + "Required": false + }, + { + "ROS": null, + "Terraform": "core_disk_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "core_instance_quantity", + "Required": false + }, + { + "ROS": "CoreInstanceType", + "Terraform": "core_instance_type", + "Required": true + }, + { + "ROS": "DeletionProtection", + "Terraform": "deletion_protection", + "Required": false + }, + { + "ROS": "DiskSize", + "Terraform": null, + "Required": false + }, + { + "ROS": "DiskType", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "duration", + "Required": false + }, + { + "ROS": "EncryptionKey", + "Terraform": null, + "Required": false + }, + { + "ROS": "Engine", + "Terraform": "engine", + "Required": true + }, + { + "ROS": "EngineVersion", + "Terraform": "engine_version", + "Required": true + }, + { + "ROS": null, + "Terraform": "immediate_delete_flag", + "Required": false + }, + { + "ROS": null, + "Terraform": "ip_white", + "Required": false + }, + { + "ROS": null, + "Terraform": "maintain_end_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "maintain_start_time", + "Required": false + }, + { + "ROS": "MasterInstanceType", + "Terraform": "master_instance_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "name", + "Required": false + }, + { + "ROS": "NodeCount", + "Terraform": null, + "Required": true + }, + { + "ROS": null, + "Terraform": "password", + "Required": false + }, + { + "ROS": "PayType", + "Terraform": "pay_type", + "Required": true + }, + { + "ROS": "Period", + "Terraform": null, + "Required": false + }, + { + "ROS": "PeriodUnit", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "security_groups", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "SecurityIPList", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "slb_conn_addrs", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": null, + "Terraform": "ui_proxy_conn_addrs", + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": null, + "Terraform": "zk_conn_addrs", + "Required": false + }, + { + "ROS": "ZoneId", + "Terraform": "zone_id", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "ClusterId", + "Terraform": null + }, + { + "ROS": "ClusterId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "master_instance_quantity" + }, + { + "ROS": "ServiceConnAddrs", + "Terraform": null + }, + { + "ROS": "SlbConnAddrs", + "Terraform": null + }, + { + "ROS": "ThriftConn", + "Terraform": null + }, + { + "ROS": "UiProxyConnAddrInfo", + "Terraform": null + }, + { + "ROS": "ZkConnAddrs", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::HBase::MultiZoneCluster", + "Terraform": null + }, + "ProductCode": "hbase", + "Name": { + "zh": "HBase MultiZoneCluster", + "en": "ApsaraDB for HBase Multi-zone Cluster" + }, + "Properties": [ + { + "ROS": "ArbiterVSwitchId", + "Terraform": null, + "Required": true + }, + { + "ROS": "ArbiterZoneId", + "Terraform": null, + "Required": true + }, + { + "ROS": "ArchVersion", + "Terraform": null, + "Required": true + }, + { + "ROS": "AutoRenewPeriod", + "Terraform": null, + "Required": false + }, + { + "ROS": "ClusterName", + "Terraform": null, + "Required": false + }, + { + "ROS": "CoreDiskSize", + "Terraform": null, + "Required": true + }, + { + "ROS": "CoreDiskType", + "Terraform": null, + "Required": true + }, + { + "ROS": "CoreInstanceType", + "Terraform": null, + "Required": true + }, + { + "ROS": "CoreNodeCount", + "Terraform": null, + "Required": true + }, + { + "ROS": "DeletionProtection", + "Terraform": null, + "Required": false + }, + { + "ROS": "Engine", + "Terraform": null, + "Required": true + }, + { + "ROS": "EngineVersion", + "Terraform": null, + "Required": true + }, + { + "ROS": "LogDiskSize", + "Terraform": null, + "Required": true + }, + { + "ROS": "LogDiskType", + "Terraform": null, + "Required": true + }, + { + "ROS": "LogInstanceType", + "Terraform": null, + "Required": true + }, + { + "ROS": "LogNodeCount", + "Terraform": null, + "Required": true + }, + { + "ROS": "MasterInstanceType", + "Terraform": null, + "Required": false + }, + { + "ROS": "MultiZoneCombination", + "Terraform": null, + "Required": true + }, + { + "ROS": "PayType", + "Terraform": null, + "Required": true + }, + { + "ROS": "Period", + "Terraform": null, + "Required": false + }, + { + "ROS": "PeriodUnit", + "Terraform": null, + "Required": false + }, + { + "ROS": "PrimaryVSwitchId", + "Terraform": null, + "Required": true + }, + { + "ROS": "PrimaryZoneId", + "Terraform": null, + "Required": true + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "SecurityIPList", + "Terraform": null, + "Required": false + }, + { + "ROS": "StandbyVSwitchId", + "Terraform": null, + "Required": true + }, + { + "ROS": "StandbyZoneId", + "Terraform": null, + "Required": true + }, + { + "ROS": "VpcId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ], + "Attributes": [ + { + "ROS": "ClusterId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "ServiceConnAddrs", + "Terraform": null + }, + { + "ROS": "SlbConnAddrs", + "Terraform": null + }, + { + "ROS": "ThriftConn", + "Terraform": null + }, + { + "ROS": "UiProxyConnAddrInfo", + "Terraform": null + }, + { + "ROS": "ZkConnAddrs", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::Hologram::Instance", + "Terraform": "alicloud_hologram_instance" + }, + "ProductCode": "hologram", + "Name": { + "zh": "Hologram Instance", + "en": "Hologres Instance" + }, + "Properties": [ + { + "ROS": "AutoPay", + "Terraform": "auto_pay", + "Required": false + }, + { + "ROS": "ColdStorageSize", + "Terraform": "cold_storage_size", + "Required": false + }, + { + "ROS": "Cpu", + "Terraform": "cpu", + "Required": false + }, + { + "ROS": "Duration", + "Terraform": "duration", + "Required": false + }, + { + "ROS": "Endpoints", + "Terraform": "endpoints", + "Required": true, + "Properties": [ + { + "ROS": "Type", + "Terraform": "type", + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": null, + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Type": "list" + }, + { + "ROS": "GatewayCount", + "Terraform": "gateway_count", + "Required": false + }, + { + "ROS": "InitialDatabases", + "Terraform": "initial_databases", + "Required": false + }, + { + "ROS": "InstanceName", + "Terraform": "instance_name", + "Required": true + }, + { + "ROS": "InstanceType", + "Terraform": "instance_type", + "Required": true + }, + { + "ROS": "LeaderInstanceId", + "Terraform": "leader_instance_id", + "Required": false + }, + { + "ROS": "PaymentType", + "Terraform": "payment_type", + "Required": true + }, + { + "ROS": "PricingCycle", + "Terraform": "pricing_cycle", + "Required": false + }, + { + "ROS": "ProductCode", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "ScaleType", + "Terraform": "scale_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": "StorageSize", + "Terraform": "storage_size", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "ZoneId", + "Terraform": "zone_id", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "AutoRenewal", + "Terraform": null + }, + { + "ROS": "ColdStorageSize", + "Terraform": null + }, + { + "ROS": "CommodityCode", + "Terraform": null + }, + { + "ROS": "ComputeNodeCount", + "Terraform": null + }, + { + "ROS": "Cpu", + "Terraform": null + }, + { + "ROS": "CreateTime", + "Terraform": "create_time" + }, + { + "ROS": "EnableHiveAccess", + "Terraform": null + }, + { + "ROS": "Endpoints", + "Terraform": "endpoints" + }, + { + "ROS": "ExpirationTime", + "Terraform": null + }, + { + "ROS": "GatewayCount", + "Terraform": null + }, + { + "ROS": "GatewayCpu", + "Terraform": null + }, + { + "ROS": "GatewayMemory", + "Terraform": null + }, + { + "ROS": "InstanceId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "InstanceName", + "Terraform": null + }, + { + "ROS": "InstanceOwner", + "Terraform": null + }, + { + "ROS": "InstanceType", + "Terraform": null + }, + { + "ROS": "Memory", + "Terraform": null + }, + { + "ROS": "PaymentType", + "Terraform": null + }, + { + "ROS": "ResourceGroupId", + "Terraform": null + }, + { + "ROS": "StorageSize", + "Terraform": null + }, + { + "ROS": "SuspendReason", + "Terraform": null + }, + { + "ROS": "Tags", + "Terraform": null + }, + { + "ROS": "Version", + "Terraform": null + }, + { + "ROS": "ZoneId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ICE::Category", + "Terraform": null + }, + "ProductCode": "ice", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "CateName", + "Terraform": null, + "Required": true + }, + { + "ROS": "ParentId", + "Terraform": null, + "Required": false + }, + { + "ROS": "Type", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "CateId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "Level", + "Terraform": null + }, + { + "ROS": "ParentId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ICE::InsertMediaToSearchLib", + "Terraform": null + }, + "ProductCode": "ice", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "Input", + "Terraform": null, + "Required": true + }, + { + "ROS": "MediaId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ICE::MediaInfo" + }, + { + "ResourceType": "ROS/ALIYUN::ICE::UploadMedia" + } + ] + }, + { + "ROS": "MediaType", + "Terraform": null, + "Required": false + }, + { + "ROS": "MsgBody", + "Terraform": null, + "Required": false + }, + { + "ROS": "SearchLibName", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "MediaId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ICE::MediaInfo", + "Terraform": null + }, + "ProductCode": "ice", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "BusinessType", + "Terraform": null, + "Required": false + }, + { + "ROS": "CateId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ALIYUN::ICE::Category" + } + ] + }, + { + "ROS": "CoverURL", + "Terraform": null, + "Required": false + }, + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "InputURL", + "Terraform": null, + "Required": true + }, + { + "ROS": "MediaTags", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "MediaType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Overwrite", + "Terraform": null, + "Required": false + }, + { + "ROS": "ReferenceId", + "Terraform": null, + "Required": false + }, + { + "ROS": "RegisterConfig", + "Terraform": null, + "Required": false + }, + { + "ROS": "SmartTagTemplateId", + "Terraform": null, + "Required": false + }, + { + "ROS": "Title", + "Terraform": null, + "Required": false + }, + { + "ROS": "UserData", + "Terraform": null, + "Required": false + }, + { + "ROS": "WorkflowId", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "MediaId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ICE::SearchLib", + "Terraform": null + }, + "ProductCode": "ice", + "Name": { + "zh": "ICE SearchLib", + "en": "ICE Search Library" + }, + "Properties": [ + { + "ROS": "SearchLibName", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "SearchLibName", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ICE::UploadMedia", + "Terraform": null + }, + "ProductCode": "ice", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "AppId", + "Terraform": null, + "Required": false + }, + { + "ROS": "EntityId", + "Terraform": null, + "Required": false + }, + { + "ROS": "FileInfo", + "Terraform": null, + "Required": false + }, + { + "ROS": "MediaMetaData", + "Terraform": null, + "Required": false + }, + { + "ROS": "PostProcessConfig", + "Terraform": null, + "Required": false + }, + { + "ROS": "UploadTargetConfig", + "Terraform": null, + "Required": false + }, + { + "ROS": "UserData", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "FileURL", + "Terraform": null + }, + { + "ROS": "MediaId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "MediaURL", + "Terraform": null + }, + { + "ROS": "UploadAddress", + "Terraform": null + }, + { + "ROS": "UploadAuth", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::IMM::Project", + "Terraform": "alicloud_imm_project" + }, + "ProductCode": "imm", + "Name": { + "zh": "智能媒体管理项目", + "en": "IMM Project" + }, + "Properties": [ + { + "ROS": "Project", + "Terraform": "project", + "Required": true + }, + { + "ROS": "ServiceRole", + "Terraform": "service_role", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Project", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::IMM::Project2", + "Terraform": null + }, + "ProductCode": "imm", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "DatasetMaxBindCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "DatasetMaxEntityCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "DatasetMaxFileCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "DatasetMaxRelationCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "DatasetMaxTotalFileSize", + "Terraform": null, + "Required": false + }, + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "ProjectMaxDatasetCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "ProjectName", + "Terraform": null, + "Required": true + }, + { + "ROS": "ServiceRole", + "Terraform": null, + "Required": false + }, + { + "ROS": "TemplateId", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "ProjectName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::IOT::Device", + "Terraform": null + }, + "ProductCode": "iot", + "Name": { + "zh": "IOT设备", + "en": "IoT Platform Device" + }, + "Properties": [ + { + "ROS": "DevEui", + "Terraform": null, + "Required": false + }, + { + "ROS": "DeviceName", + "Terraform": null, + "Required": false + }, + { + "ROS": "IotInstanceId", + "Terraform": null, + "Required": false + }, + { + "ROS": "Nickname", + "Terraform": null, + "Required": false + }, + { + "ROS": "PinCode", + "Terraform": null, + "Required": false + }, + { + "ROS": "ProductKey", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "DeviceName", + "Terraform": null + }, + { + "ROS": "DeviceSecret", + "Terraform": null + }, + { + "ROS": "IotId", + "Terraform": null + }, + { + "ROS": "IotInstanceId", + "Terraform": null + }, + { + "ROS": "IpAddress", + "Terraform": null + }, + { + "ROS": "NickName", + "Terraform": null + }, + { + "ROS": "NodeType", + "Terraform": null + }, + { + "ROS": "ProductKey", + "Terraform": null + }, + { + "ROS": "ProductName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::IOT::DeviceGroup", + "Terraform": "alicloud_iot_device_group" + }, + "ProductCode": "iot", + "Name": { + "zh": "IOT设备分组", + "en": "IoT Platform Device Group" + }, + "Properties": [ + { + "ROS": "GroupDesc", + "Terraform": "group_desc", + "Required": false + }, + { + "ROS": "GroupName", + "Terraform": "group_name", + "Required": true + }, + { + "ROS": "IotInstanceId", + "Terraform": "iot_instance_id", + "Required": false + }, + { + "ROS": "SuperGroupId", + "Terraform": "super_group_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "GroupId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "IotInstanceId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::IOT::Product", + "Terraform": null + }, + "ProductCode": "iot", + "Name": { + "zh": "IOT产品", + "en": "IoT Platform Product" + }, + "Properties": [ + { + "ROS": "AliyunCommodityCode", + "Terraform": null, + "Required": false + }, + { + "ROS": "AuthType", + "Terraform": null, + "Required": false + }, + { + "ROS": "CategoryKey", + "Terraform": null, + "Required": false + }, + { + "ROS": "DataFormat", + "Terraform": null, + "Required": false + }, + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "Id2", + "Terraform": null, + "Required": false + }, + { + "ROS": "IotInstanceId", + "Terraform": null, + "Required": false + }, + { + "ROS": "JoinPermissionId", + "Terraform": null, + "Required": false + }, + { + "ROS": "NetType", + "Terraform": null, + "Required": false + }, + { + "ROS": "NodeType", + "Terraform": null, + "Required": true + }, + { + "ROS": "ProductName", + "Terraform": null, + "Required": true + }, + { + "ROS": "ProtocolType", + "Terraform": null, + "Required": false + }, + { + "ROS": "PublishAuto", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + } + ], + "Attributes": [ + { + "ROS": "IotInstanceId", + "Terraform": null + }, + { + "ROS": "ProductKey", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::IOT::ProductTopic", + "Terraform": null + }, + "ProductCode": "iot", + "Name": { + "zh": "IOT自定义Topic类", + "en": "Custom Topic Category of IoT Platform" + }, + "Properties": [ + { + "ROS": "Desc", + "Terraform": null, + "Required": false + }, + { + "ROS": "IotInstanceId", + "Terraform": null, + "Required": false + }, + { + "ROS": "Operation", + "Terraform": null, + "Required": true + }, + { + "ROS": "ProductKey", + "Terraform": null, + "Required": true + }, + { + "ROS": "TopicShortName", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "TopicId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::IOT::Rule", + "Terraform": null + }, + "ProductCode": "iot", + "Name": { + "zh": "IOT规则", + "en": "IoT Platform Rule" + }, + "Properties": [ + { + "ROS": "DataType", + "Terraform": null, + "Required": false + }, + { + "ROS": "IotInstanceId", + "Terraform": null, + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "ProductKey", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "RuleAction", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Configuration", + "Terraform": null, + "Required": true + }, + { + "ROS": "ErrorActionFlag", + "Terraform": null, + "Required": false + }, + { + "ROS": "Type", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "RuleDesc", + "Terraform": null, + "Required": false + }, + { + "ROS": "Select", + "Terraform": null, + "Required": false + }, + { + "ROS": "ShortTopic", + "Terraform": null, + "Required": false + }, + { + "ROS": "StartRule", + "Terraform": null, + "Required": false + }, + { + "ROS": "TopicType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Where", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "ActionId", + "Terraform": null + }, + { + "ROS": "RuleId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::IOT::RuleAction", + "Terraform": null + }, + "ProductCode": "iot", + "Name": { + "zh": "IOT规则动作", + "en": "IoT Platform Rule Action" + }, + "Properties": [ + { + "ROS": "Configuration", + "Terraform": null, + "Required": true + }, + { + "ROS": "ErrorActionFlag", + "Terraform": null, + "Required": false + }, + { + "ROS": "IotInstanceId", + "Terraform": null, + "Required": false + }, + { + "ROS": "RuleId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::IOT::Rule" + } + ] + }, + { + "ROS": "Type", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "ActionId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::KAFKA::Acl", + "Terraform": null + }, + "ProductCode": "alikafka", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "AclOperationTypes", + "Terraform": null, + "Required": true, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "AclPermissionType", + "Terraform": null, + "Required": false + }, + { + "ROS": "AclResourceName", + "Terraform": null, + "Required": true + }, + { + "ROS": "AclResourcePatternType", + "Terraform": null, + "Required": true + }, + { + "ROS": "AclResourceType", + "Terraform": null, + "Required": true + }, + { + "ROS": "Host", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::KAFKA::Instance" + } + ] + }, + { + "ROS": "Username", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "AclResourceType", + "Terraform": null + }, + { + "ROS": "InstanceId", + "Terraform": null + }, + { + "ROS": "Username", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::KAFKA::ConsumerGroup", + "Terraform": "alicloud_alikafka_consumer_group" + }, + "ProductCode": "alikafka", + "Name": { + "zh": "KAFKA ConsumerGroup", + "en": "ApsaraMQ for Kafka Consumer Group" + }, + "Properties": [ + { + "ROS": "ConsumerId", + "Terraform": "consumer_id", + "Required": true + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": "InstanceId", + "Terraform": "instance_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::KAFKA::Instance" + } + ] + }, + { + "ROS": "Remark", + "Terraform": null, + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": "ConsumerId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::KAFKA::Instance", + "Terraform": "alicloud_alikafka_instance" + }, + "ProductCode": "alikafka", + "Name": { + "zh": "KAFKA实例", + "en": "ApsaraMQ for Kafka Instance" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "config", + "Required": false + }, + { + "ROS": "DeletionForce", + "Terraform": null, + "Required": false + }, + { + "ROS": "DeployOption", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Config", + "Terraform": null, + "Required": false + }, + { + "ROS": "CrossZone", + "Terraform": null, + "Required": false + }, + { + "ROS": "DeployModule", + "Terraform": null, + "Required": true + }, + { + "ROS": "IsEipInner", + "Terraform": null, + "Required": false + }, + { + "ROS": "IsForceSelectedZones", + "Terraform": null, + "Required": false + }, + { + "ROS": "IsSetUserAndPassword", + "Terraform": null, + "Required": false + }, + { + "ROS": "KMSKeyId", + "Terraform": null, + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": false + }, + { + "ROS": "Notifier", + "Terraform": null, + "Required": false + }, + { + "ROS": "Password", + "Terraform": null, + "Required": false + }, + { + "ROS": "SecurityGroup", + "Terraform": null, + "Required": false + }, + { + "ROS": "SelectedZones", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "ServiceVersion", + "Terraform": null, + "Required": false + }, + { + "ROS": "Username", + "Terraform": null, + "Required": false + }, + { + "ROS": "UserPhoneNum", + "Terraform": null, + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "VSwitchIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "ZoneId", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "DeployType", + "Terraform": "deploy_type", + "Required": true + }, + { + "ROS": "DiskSize", + "Terraform": "disk_size", + "Required": false + }, + { + "ROS": "DiskType", + "Terraform": "disk_type", + "Required": false + }, + { + "ROS": "EipMax", + "Terraform": "eip_max", + "Required": false + }, + { + "ROS": "IoMax", + "Terraform": "io_max", + "Required": false + }, + { + "ROS": "IoMaxSpec", + "Terraform": "io_max_spec", + "Required": false + }, + { + "ROS": null, + "Terraform": "kms_key_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "name", + "Required": false + }, + { + "ROS": "OpenConnector", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "paid_type", + "Required": false + }, + { + "ROS": "PartitionNum", + "Terraform": "partition_num", + "Required": false + }, + { + "ROS": "PayType", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "security_group", + "Required": false + }, + { + "ROS": null, + "Terraform": "selected_zones", + "Required": false + }, + { + "ROS": "ServerlessConfig", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "ReservedPublishCapacity", + "Terraform": null, + "Required": true + }, + { + "ROS": "ReservedSubscribeCapacity", + "Terraform": null, + "Required": true + } + ] + }, + { + "ROS": null, + "Terraform": "service_version", + "Required": false + }, + { + "ROS": "SpecType", + "Terraform": "spec_type", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "TopicQuota", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": null, + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": null, + "Terraform": "zone_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": "DomainEndpoint", + "Terraform": null + }, + { + "ROS": "Endpoint", + "Terraform": "end_point" + }, + { + "ROS": null, + "Terraform": "group_left" + }, + { + "ROS": null, + "Terraform": "group_used" + }, + { + "ROS": "InstanceId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "is_partition_buy" + }, + { + "ROS": "Name", + "Terraform": null + }, + { + "ROS": "OrderId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "partition_left" + }, + { + "ROS": null, + "Terraform": "partition_used" + }, + { + "ROS": "SaslDomainEndpoint", + "Terraform": null + }, + { + "ROS": "SslDomainEndpoint", + "Terraform": null + }, + { + "ROS": "SslEndpoint", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": null, + "Terraform": "topic_left" + }, + { + "ROS": null, + "Terraform": "topic_num_of_buy" + }, + { + "ROS": null, + "Terraform": "topic_used" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::KAFKA::SaslUser", + "Terraform": "alicloud_alikafka_sasl_user" + }, + "ProductCode": "alikafka", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "InstanceId", + "Terraform": "instance_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::KAFKA::Instance" + } + ] + }, + { + "ROS": null, + "Terraform": "kms_encrypted_password", + "Required": false + }, + { + "ROS": null, + "Terraform": "kms_encryption_context", + "Required": false + }, + { + "ROS": "Mechanism", + "Terraform": null, + "Required": false + }, + { + "ROS": "Password", + "Terraform": "password", + "Required": true + }, + { + "ROS": "Type", + "Terraform": "type", + "Required": false + }, + { + "ROS": "Username", + "Terraform": "username", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "Username", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "InstanceId", + "Terraform": null + }, + { + "ROS": "Username", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::KAFKA::Topic", + "Terraform": "alicloud_alikafka_topic" + }, + "ProductCode": "alikafka", + "Name": { + "zh": "KAFKA Topic", + "en": "ApsaraMQ for Kafka Topic" + }, + "Properties": [ + { + "ROS": "CompactTopic", + "Terraform": "compact_topic", + "Required": false + }, + { + "ROS": "Config", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceId", + "Terraform": "instance_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::KAFKA::Instance" + } + ] + }, + { + "ROS": "LocalTopic", + "Terraform": "local_topic", + "Required": false + }, + { + "ROS": "MinInsyncReplicas", + "Terraform": null, + "Required": false + }, + { + "ROS": "PartitionNum", + "Terraform": "partition_num", + "Required": false + }, + { + "ROS": "Remark", + "Terraform": "remark", + "Required": true + }, + { + "ROS": "ReplicationFactor", + "Terraform": null, + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "Topic", + "Terraform": "topic", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": "Topic", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "InstanceId", + "Terraform": null + }, + { + "ROS": "Topic", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::KMS::Alias", + "Terraform": "alicloud_kms_alias" + }, + "ProductCode": "kms", + "Name": { + "zh": "KMS别名", + "en": "KMS Key Alias" + }, + "Properties": [ + { + "ROS": "AliasName", + "Terraform": "alias_name", + "Required": true + }, + { + "ROS": "KeyId", + "Terraform": "key_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::KMS::Key" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::KMS::Instance", + "Terraform": "alicloud_kms_instance" + }, + "ProductCode": "kms", + "Name": { + "zh": "KMS实例", + "en": "KMS Instance" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "bind_vpcs", + "Required": false + }, + { + "ROS": "Connection", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "VpcId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchIds", + "Terraform": null, + "Required": true, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "ZoneIds", + "Terraform": null, + "Required": true, + "Properties": {}, + "Type": "list" + } + ] + }, + { + "ROS": null, + "Terraform": "force_delete_without_backup", + "Required": false + }, + { + "ROS": "InstanceChargeType", + "Terraform": null, + "Required": false + }, + { + "ROS": "KeyNum", + "Terraform": "key_num", + "Required": false + }, + { + "ROS": "Log", + "Terraform": "log", + "Required": false + }, + { + "ROS": "LogStorage", + "Terraform": "log_storage", + "Required": false + }, + { + "ROS": null, + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": "Period", + "Terraform": "period", + "Required": false + }, + { + "ROS": "PeriodUnit", + "Terraform": null, + "Required": false + }, + { + "ROS": "ProductVersion", + "Terraform": "product_version", + "Required": true + }, + { + "ROS": "RenewPeriod", + "Terraform": "renew_period", + "Required": false + }, + { + "ROS": "RenewStatus", + "Terraform": "renew_status", + "Required": false + }, + { + "ROS": "SecretNum", + "Terraform": "secret_num", + "Required": false + }, + { + "ROS": "Spec", + "Terraform": "spec", + "Required": false + }, + { + "ROS": null, + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VpcNum", + "Terraform": "vpc_num", + "Required": false + }, + { + "ROS": null, + "Terraform": "vswitch_ids", + "Required": false + }, + { + "ROS": null, + "Terraform": "zone_ids", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "ca_certificate_chain_pem" + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "InstanceId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "instance_name" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::KMS::Key", + "Terraform": "alicloud_kms_key" + }, + "ProductCode": "kms", + "Name": { + "zh": "主密钥", + "en": "CMK" + }, + "Properties": [ + { + "ROS": "EnableAutomaticRotation", + "Terraform": "automatic_rotation", + "Required": false + }, + { + "ROS": "DeletionProtection", + "Terraform": null, + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "DKMSInstanceId", + "Terraform": "dkms_instance_id", + "Required": false + }, + { + "ROS": "Enable", + "Terraform": null, + "Required": false + }, + { + "ROS": "KeySpec", + "Terraform": "key_spec", + "Required": false + }, + { + "ROS": "KeyUsage", + "Terraform": "key_usage", + "Required": false + }, + { + "ROS": null, + "Terraform": "origin", + "Required": false + }, + { + "ROS": "PendingWindowInDays", + "Terraform": "pending_window_in_days", + "Required": false + }, + { + "ROS": "Policy", + "Terraform": "policy", + "Required": false + }, + { + "ROS": "ProtectionLevel", + "Terraform": "protection_level", + "Required": false + }, + { + "ROS": "RotationInterval", + "Terraform": "rotation_interval", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "arn" + }, + { + "ROS": null, + "Terraform": "creation_date" + }, + { + "ROS": null, + "Terraform": "creator" + }, + { + "ROS": null, + "Terraform": "delete_date" + }, + { + "ROS": "KeyId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "last_rotation_date" + }, + { + "ROS": null, + "Terraform": "material_expire_time" + }, + { + "ROS": null, + "Terraform": "next_rotation_date" + }, + { + "ROS": null, + "Terraform": "primary_key_version" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::KMS::NetworkRule", + "Terraform": "alicloud_kms_network_rule" + }, + "ProductCode": "kms", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "NetworkRuleName", + "Terraform": "network_rule_name", + "Required": true + }, + { + "ROS": "SourcePrivateIp", + "Terraform": "source_private_ip", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Description", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "SourcePrivateIp", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::KMS::Policy", + "Terraform": "alicloud_kms_policy" + }, + "ProductCode": "kms", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "AccessControlRules", + "Terraform": "access_control_rules", + "Required": true + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "KmsInstanceId", + "Terraform": "kms_instance_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::KMS::Instance" + } + ] + }, + { + "ROS": "Permissions", + "Terraform": "permissions", + "Required": true + }, + { + "ROS": "PolicyName", + "Terraform": "policy_name", + "Required": true + }, + { + "ROS": "Resources", + "Terraform": "resources", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "AccessControlRules", + "Terraform": null + }, + { + "ROS": "Description", + "Terraform": null + }, + { + "ROS": "PolicyName", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "KmsInstanceId", + "Terraform": null + }, + { + "ROS": "Permissions", + "Terraform": null + }, + { + "ROS": "PolicyName", + "Terraform": null + }, + { + "ROS": "Resources", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::KMS::Secret", + "Terraform": "alicloud_kms_secret" + }, + "ProductCode": "kms", + "Name": { + "zh": "主密钥凭据", + "en": "CMK Credential" + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "DKMSInstanceId", + "Terraform": "dkms_instance_id", + "Required": false + }, + { + "ROS": "EnableAutomaticRotation", + "Terraform": "enable_automatic_rotation", + "Required": false + }, + { + "ROS": "EncryptionKeyId", + "Terraform": "encryption_key_id", + "Required": false + }, + { + "ROS": "ExtendedConfig", + "Terraform": "extended_config", + "Required": false + }, + { + "ROS": "ForceDeleteWithoutRecovery", + "Terraform": "force_delete_without_recovery", + "Required": false + }, + { + "ROS": null, + "Terraform": "policy", + "Required": false + }, + { + "ROS": "RecoveryWindowInDays", + "Terraform": "recovery_window_in_days", + "Required": false + }, + { + "ROS": "RotationInterval", + "Terraform": "rotation_interval", + "Required": false + }, + { + "ROS": "SecretData", + "Terraform": "secret_data", + "Required": true + }, + { + "ROS": "SecretDataType", + "Terraform": "secret_data_type", + "Required": false + }, + { + "ROS": "SecretName", + "Terraform": "secret_name", + "Required": true + }, + { + "ROS": "SecretType", + "Terraform": "secret_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": "VersionId", + "Terraform": "version_id", + "Required": true + }, + { + "ROS": "VersionStages", + "Terraform": "version_stages", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": "arn" + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "SecretName", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "planned_delete_time" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::Lindorm::Instance", + "Terraform": "alicloud_lindorm_instance" + }, + "ProductCode": "hitsdb", + "Name": { + "zh": "Lindorm实例", + "en": "Lindorm Instance" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "arbiter_vswitch_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "arbiter_zone_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "arch_version", + "Required": false + }, + { + "ROS": "ColdStorage", + "Terraform": "cold_storage", + "Required": false + }, + { + "ROS": null, + "Terraform": "core_single_storage", + "Required": false + }, + { + "ROS": "CoreSpec", + "Terraform": "core_spec", + "Required": false + }, + { + "ROS": null, + "Terraform": "deletion_proection", + "Required": false + }, + { + "ROS": "DeletionProtection", + "Terraform": null, + "Required": false + }, + { + "ROS": "DiskCategory", + "Terraform": "disk_category", + "Required": true + }, + { + "ROS": "Period", + "Terraform": "duration", + "Required": false + }, + { + "ROS": "FilestoreNum", + "Terraform": "file_engine_node_count", + "Required": false + }, + { + "ROS": "FilestoreSpec", + "Terraform": "file_engine_specification", + "Required": false + }, + { + "ROS": null, + "Terraform": "group_name", + "Required": false + }, + { + "ROS": "InstanceName", + "Terraform": "instance_name", + "Required": true + }, + { + "ROS": "InstanceStorage", + "Terraform": "instance_storage", + "Required": false + }, + { + "ROS": null, + "Terraform": "ip_white_list", + "Required": false + }, + { + "ROS": "LindormNum", + "Terraform": null, + "Required": false + }, + { + "ROS": "LindormSpec", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "log_disk_category", + "Required": false + }, + { + "ROS": null, + "Terraform": "log_num", + "Required": false + }, + { + "ROS": null, + "Terraform": "log_single_storage", + "Required": false + }, + { + "ROS": null, + "Terraform": "log_spec", + "Required": false + }, + { + "ROS": null, + "Terraform": "lts_node_count", + "Required": false + }, + { + "ROS": null, + "Terraform": "lts_node_specification", + "Required": false + }, + { + "ROS": null, + "Terraform": "multi_zone_combination", + "Required": false + }, + { + "ROS": "InstanceChargeType", + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "phoenix_node_count", + "Required": false + }, + { + "ROS": null, + "Terraform": "phoenix_node_specification", + "Required": false + }, + { + "ROS": "PeriodUnit", + "Terraform": "pricing_cycle", + "Required": false + }, + { + "ROS": null, + "Terraform": "primary_vswitch_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "primary_zone_id", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "SolrNum", + "Terraform": "search_engine_node_count", + "Required": false + }, + { + "ROS": "SolrSpec", + "Terraform": "search_engine_specification", + "Required": false + }, + { + "ROS": "SecurityIpList", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": null, + "Terraform": "standby_vswitch_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "standby_zone_id", + "Required": false + }, + { + "ROS": "StreamNum", + "Terraform": "stream_engine_node_count", + "Required": false + }, + { + "ROS": "StreamSpec", + "Terraform": "stream_engine_specification", + "Required": false + }, + { + "ROS": null, + "Terraform": "table_engine_node_count", + "Required": false + }, + { + "ROS": null, + "Terraform": "table_engine_specification", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": null, + "Terraform": "time_series_engine_node_count", + "Required": false + }, + { + "ROS": null, + "Terraform": "time_series_engine_specification", + "Required": false + }, + { + "ROS": "TsdbNum", + "Terraform": null, + "Required": false + }, + { + "ROS": "TsdbSpec", + "Terraform": null, + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "ZoneId", + "Terraform": "zone_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "AuthInfos", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "enabled_file_engine" + }, + { + "ROS": null, + "Terraform": "enabled_lts_engine" + }, + { + "ROS": null, + "Terraform": "enabled_search_engine" + }, + { + "ROS": null, + "Terraform": "enabled_stream_engine" + }, + { + "ROS": null, + "Terraform": "enabled_table_engine" + }, + { + "ROS": null, + "Terraform": "enabled_time_serires_engine" + }, + { + "ROS": "InstanceId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "JdbcUrlList", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "service_type" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::Lindorm::MultiZoneInstance", + "Terraform": null + }, + "ProductCode": "hitsdb", + "Name": { + "zh": "Lindorm MultiZoneInstance", + "en": "Multi-zone Lindorm Instance" + }, + "Properties": [ + { + "ROS": "ArbiterVSwitchId", + "Terraform": null, + "Required": false + }, + { + "ROS": "ArbiterZoneId", + "Terraform": null, + "Required": false + }, + { + "ROS": "ColdStorage", + "Terraform": null, + "Required": false + }, + { + "ROS": "CoreSingleStorage", + "Terraform": null, + "Required": false + }, + { + "ROS": "CoreSpec", + "Terraform": null, + "Required": false + }, + { + "ROS": "DeletionProtection", + "Terraform": null, + "Required": false + }, + { + "ROS": "DiskCategory", + "Terraform": null, + "Required": true + }, + { + "ROS": "FilestoreNum", + "Terraform": null, + "Required": false + }, + { + "ROS": "FilestoreSpec", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceChargeType", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceName", + "Terraform": null, + "Required": true + }, + { + "ROS": "LindormNum", + "Terraform": null, + "Required": false + }, + { + "ROS": "LindormSpec", + "Terraform": null, + "Required": false + }, + { + "ROS": "LogDiskCategory", + "Terraform": null, + "Required": false + }, + { + "ROS": "LogNum", + "Terraform": null, + "Required": false + }, + { + "ROS": "LogSingleStorage", + "Terraform": null, + "Required": false + }, + { + "ROS": "LogSpec", + "Terraform": null, + "Required": false + }, + { + "ROS": "MultiZoneCombination", + "Terraform": null, + "Required": false + }, + { + "ROS": "Period", + "Terraform": null, + "Required": false + }, + { + "ROS": "PeriodUnit", + "Terraform": null, + "Required": false + }, + { + "ROS": "PrimaryVSwitchId", + "Terraform": null, + "Required": false + }, + { + "ROS": "PrimaryZoneId", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "SecurityIpList", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "SolrNum", + "Terraform": null, + "Required": false + }, + { + "ROS": "SolrSpec", + "Terraform": null, + "Required": false + }, + { + "ROS": "StandbyVSwitchId", + "Terraform": null, + "Required": false + }, + { + "ROS": "StandbyZoneId", + "Terraform": null, + "Required": false + }, + { + "ROS": "StreamNum", + "Terraform": null, + "Required": false + }, + { + "ROS": "StreamSpec", + "Terraform": null, + "Required": false + }, + { + "ROS": "TsdbNum", + "Terraform": null, + "Required": false + }, + { + "ROS": "TsdbSpec", + "Terraform": null, + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ], + "Attributes": [ + { + "ROS": "AuthInfos", + "Terraform": null + }, + { + "ROS": "InstanceId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "JdbcUrlList", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::MNS::Queue", + "Terraform": "alicloud_message_service_queue" + }, + "ProductCode": "mns", + "Name": { + "zh": "MNS队列", + "en": "Simple Message Queue (formerly MNS) Queue" + }, + "Properties": [ + { + "ROS": "DelaySeconds", + "Terraform": "delay_seconds", + "Required": false + }, + { + "ROS": "LoggingEnabled", + "Terraform": "logging_enabled", + "Required": false + }, + { + "ROS": "MaximumMessageSize", + "Terraform": "maximum_message_size", + "Required": false + }, + { + "ROS": "MessageRetentionPeriod", + "Terraform": "message_retention_period", + "Required": false + }, + { + "ROS": "QueueName", + "Terraform": "name", + "Required": false + }, + { + "ROS": "PollingWaitSeconds", + "Terraform": "polling_wait_seconds", + "Required": false + }, + { + "ROS": "QueueName", + "Terraform": "queue_name", + "Required": true + }, + { + "ROS": "VisibilityTimeout", + "Terraform": "visibility_timeout", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "ARN.WithSlash", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "QueueName", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "QueueUrl", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::MNS::Subscription", + "Terraform": "alicloud_message_service_subscription" + }, + "ProductCode": "mns", + "Name": { + "zh": "MNS订阅", + "en": "Simple Message Queue (formerly MNS) Subscription" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "Email Format", + "Required": false + }, + { + "ROS": "Endpoint", + "Terraform": "endpoint", + "Required": true + }, + { + "ROS": "FilterTag", + "Terraform": "filter_tag", + "Required": false + }, + { + "ROS": null, + "Terraform": "HTTP Format", + "Required": false + }, + { + "ROS": "SubscriptionName", + "Terraform": "name", + "Required": false + }, + { + "ROS": "NotifyContentFormat", + "Terraform": "notify_content_format", + "Required": false + }, + { + "ROS": "NotifyStrategy", + "Terraform": "notify_strategy", + "Required": false + }, + { + "ROS": null, + "Terraform": "push_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "Queue Format", + "Required": false + }, + { + "ROS": "SubscriptionName", + "Terraform": "subscription_name", + "Required": true + }, + { + "ROS": "TopicName", + "Terraform": "topic_name", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::MNS::Topic" + } + ] + } + ], + "Attributes": [ + { + "ROS": "SubscriptionName", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "SubscriptionUrl", + "Terraform": null + }, + { + "ROS": "TopicName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::MNS::Topic", + "Terraform": "alicloud_message_service_topic" + }, + "ProductCode": "mns", + "Name": { + "zh": "MNS主题", + "en": "Simple Message Queue (formerly MNS) Topic" + }, + "Properties": [ + { + "ROS": "LoggingEnabled", + "Terraform": "logging_enabled", + "Required": false + }, + { + "ROS": "MaximumMessageSize", + "Terraform": "maximum_message_size", + "Required": false + }, + { + "ROS": null, + "Terraform": "max_message_size", + "Required": false + }, + { + "ROS": "TopicName", + "Terraform": "name", + "Required": false + }, + { + "ROS": "TopicName", + "Terraform": "topic_name", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "ARN.WithSlash", + "Terraform": null + }, + { + "ROS": "TopicName", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "TopicUrl", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::MOBI::App", + "Terraform": null + }, + "ProductCode": "miniappdev", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "AppDescription", + "Terraform": null, + "Required": false + }, + { + "ROS": "AppIcon", + "Terraform": null, + "Required": true + }, + { + "ROS": "AppName", + "Terraform": null, + "Required": true + }, + { + "ROS": "AppType", + "Terraform": null, + "Required": false + }, + { + "ROS": "AppWorkspaceId", + "Terraform": null, + "Required": true + }, + { + "ROS": "Template", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "ActualParameters", + "Terraform": null, + "Required": false + }, + { + "ROS": "ConnectionsContent", + "Terraform": null, + "Required": true + }, + { + "ROS": "TemplateId", + "Terraform": null, + "Required": true + } + ] + } + ], + "Attributes": [ + { + "ROS": "AppDescription", + "Terraform": null + }, + { + "ROS": "AppIcon", + "Terraform": null + }, + { + "ROS": "AppId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "AppName", + "Terraform": null + }, + { + "ROS": "AppType", + "Terraform": null + }, + { + "ROS": "AppWorkspaceId", + "Terraform": null + }, + { + "ROS": "CreateTime", + "Terraform": null + }, + { + "ROS": "ModifiedTime", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::MONGODB::Instance", + "Terraform": "alicloud_mongodb_instance" + }, + "ProductCode": "mongodb", + "Name": { + "zh": "MongoDB实例", + "en": "ApsaraDB for MongoDB Instance" + }, + "Properties": [ + { + "ROS": "AccountPassword", + "Terraform": "account_password", + "Required": false + }, + { + "ROS": "AutoRenew", + "Terraform": "auto_renew", + "Required": false + }, + { + "ROS": "BackupId", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "backup_interval", + "Required": false + }, + { + "ROS": null, + "Terraform": "backup_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "backup_retention_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "backup_time", + "Required": false + }, + { + "ROS": "BusinessInfo", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "cloud_disk_encryption_key", + "Required": false + }, + { + "ROS": "CouponNo", + "Terraform": null, + "Required": false + }, + { + "ROS": "DatabaseNames", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "db_instance_class", + "Required": false + }, + { + "ROS": "DBInstanceClass", + "Terraform": "db_instance_storage", + "Required": true + }, + { + "ROS": null, + "Terraform": "effective_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "enable_backup_log", + "Required": false + }, + { + "ROS": null, + "Terraform": "encrypted", + "Required": false + }, + { + "ROS": null, + "Terraform": "encryption_key", + "Required": false + }, + { + "ROS": null, + "Terraform": "encryptor_name", + "Required": false + }, + { + "ROS": "EngineVersion", + "Terraform": "engine_version", + "Required": false + }, + { + "ROS": "HiddenZoneId", + "Terraform": "hidden_zone_id", + "Required": false + }, + { + "ROS": "ChargeType", + "Terraform": "instance_charge_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "kms_encrypted_password", + "Required": false + }, + { + "ROS": null, + "Terraform": "kms_encryption_context", + "Required": false + }, + { + "ROS": null, + "Terraform": "log_backup_retention_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "maintain_end_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "maintain_start_time", + "Required": false + }, + { + "ROS": "DBInstanceDescription", + "Terraform": "name", + "Required": false + }, + { + "ROS": "NetworkType", + "Terraform": "network_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "order_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "parameters", + "Required": false + }, + { + "ROS": "Period", + "Terraform": "period", + "Required": false + }, + { + "ROS": "PrivateConnections", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "ReplicaConnections", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "ConnectionPort", + "Terraform": null, + "Required": true + }, + { + "ROS": "ConnectionString", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + } + ] + }, + { + "ROS": null, + "Terraform": "provisioned_iops", + "Required": false + }, + { + "ROS": "ReadonlyReplicas", + "Terraform": "readonly_replicas", + "Required": false + }, + { + "ROS": "ReplicationFactor", + "Terraform": "replication_factor", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "RestoreTime", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "role_arn", + "Required": false + }, + { + "ROS": "SecondaryZoneId", + "Terraform": "secondary_zone_id", + "Required": false + }, + { + "ROS": "SecurityGroupId", + "Terraform": "security_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "SecurityIPArray", + "Terraform": "security_ip_list", + "Required": false + }, + { + "ROS": null, + "Terraform": "snapshot_backup_type", + "Required": false + }, + { + "ROS": "SrcDBInstanceId", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "ssl_action", + "Required": false + }, + { + "ROS": "StorageEngine", + "Terraform": "storage_engine", + "Required": false + }, + { + "ROS": "StorageType", + "Terraform": "storage_type", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "TDEStatus", + "Terraform": "tde_status", + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VpcPasswordFree", + "Terraform": null, + "Required": false + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "ZoneId", + "Terraform": "zone_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": "ConnectionURI", + "Terraform": null + }, + { + "ROS": "DBInstanceStatus", + "Terraform": null + }, + { + "ROS": "DBInstanceId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "OrderId", + "Terraform": null + }, + { + "ROS": "ReplicaSetName", + "Terraform": "replica_set_name" + }, + { + "ROS": null, + "Terraform": "replica_sets" + }, + { + "ROS": null, + "Terraform": "retention_period" + }, + { + "ROS": null, + "Terraform": "ssl_status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::MONGODB::ShardingInstance", + "Terraform": "alicloud_mongodb_sharding_instance" + }, + "ProductCode": "mongodb", + "Name": { + "zh": "MongoDB分片集群实例", + "en": "ApsaraDB for MongoDB Sharded Cluster Instance" + }, + "Properties": [ + { + "ROS": "AccountPassword", + "Terraform": "account_password", + "Required": false + }, + { + "ROS": "AutoRenew", + "Terraform": "auto_renew", + "Required": false + }, + { + "ROS": null, + "Terraform": "backup_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "backup_time", + "Required": false + }, + { + "ROS": "ConfigServer", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "Class", + "Terraform": null, + "Required": true + }, + { + "ROS": "Storage", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": null, + "Terraform": "config_server_list", + "Required": false + }, + { + "ROS": "EngineVersion", + "Terraform": "engine_version", + "Required": false + }, + { + "ROS": "HiddenZoneId", + "Terraform": null, + "Required": false + }, + { + "ROS": "ChargeType", + "Terraform": "instance_charge_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "kms_encrypted_password", + "Required": false + }, + { + "ROS": null, + "Terraform": "kms_encryption_context", + "Required": false + }, + { + "ROS": "Mongos", + "Terraform": "mongo_list", + "Required": true, + "Properties": [ + { + "ROS": "Class", + "Terraform": "node_class", + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "DBInstanceDescription", + "Terraform": "name", + "Required": false + }, + { + "ROS": "NetworkType", + "Terraform": "network_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "order_type", + "Required": false + }, + { + "ROS": "Period", + "Terraform": "period", + "Required": false + }, + { + "ROS": "ProtocolType", + "Terraform": "protocol_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "provisioned_iops", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "RestoreTime", + "Terraform": null, + "Required": false + }, + { + "ROS": "SecondaryZoneId", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "security_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "SecurityIPArray", + "Terraform": "security_ip_list", + "Required": false + }, + { + "ROS": "ReplicaSet", + "Terraform": "shard_list", + "Required": true, + "Properties": [ + { + "ROS": "Class", + "Terraform": "node_class", + "Required": true + }, + { + "ROS": "Storage", + "Terraform": "node_storage", + "Required": true + }, + { + "ROS": "ReadonlyReplicas", + "Terraform": "readonly_replicas", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "SrcDBInstanceId", + "Terraform": null, + "Required": false + }, + { + "ROS": "StorageEngine", + "Terraform": "storage_engine", + "Required": false + }, + { + "ROS": "StorageType", + "Terraform": "storage_type", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "TDEStatus", + "Terraform": "tde_status", + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "ZoneId", + "Terraform": "zone_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "config_server_list" + }, + { + "ROS": "DBInstanceStatus", + "Terraform": null + }, + { + "ROS": "DBInstanceId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "mongo_list" + }, + { + "ROS": "OrderId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "retention_period" + }, + { + "ROS": null, + "Terraform": "shard_list" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::MPS::MediaWorkflow", + "Terraform": null + }, + "ProductCode": "mts", + "Name": { + "zh": "MPS MediaWorkflow", + "en": "MPS Media Workflow" + }, + "Properties": [ + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "Topology", + "Terraform": null, + "Required": true + }, + { + "ROS": "TriggerMode", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "CreationTime", + "Terraform": null + }, + { + "ROS": "MediaWorkflowId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "Name", + "Terraform": null + }, + { + "ROS": "State", + "Terraform": null + }, + { + "ROS": "Topology", + "Terraform": null + }, + { + "ROS": "TriggerMode", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::MPS::Pipeline", + "Terraform": null + }, + "ProductCode": "mts", + "Name": { + "zh": "MPS Pipeline", + "en": "MPS Pipeline" + }, + "Properties": [ + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "NotifyConfig", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "QueueName", + "Terraform": null, + "Required": false + }, + { + "ROS": "Topic", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "Role", + "Terraform": null, + "Required": false + }, + { + "ROS": "Speed", + "Terraform": null, + "Required": false + }, + { + "ROS": "SpeedLevel", + "Terraform": null, + "Required": false + }, + { + "ROS": "State", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "PipelineId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::MSE::Cluster", + "Terraform": "alicloud_mse_cluster" + }, + "ProductCode": "mse", + "Name": { + "zh": "MSE集群", + "en": "MSE Cluster" + }, + "Properties": [ + { + "ROS": "AcceptLanguage", + "Terraform": null, + "Required": false + }, + { + "ROS": "AclEntryList", + "Terraform": "acl_entry_list", + "Required": false + }, + { + "ROS": "ClusterAliasName", + "Terraform": "cluster_alias_name", + "Required": false + }, + { + "ROS": "ClusterSpecification", + "Terraform": "cluster_specification", + "Required": true + }, + { + "ROS": "ClusterType", + "Terraform": "cluster_type", + "Required": true + }, + { + "ROS": "ClusterVersion", + "Terraform": "cluster_version", + "Required": true + }, + { + "ROS": "ConnectionType", + "Terraform": "connection_type", + "Required": false + }, + { + "ROS": "DiskType", + "Terraform": "disk_type", + "Required": false + }, + { + "ROS": "InstanceCount", + "Terraform": "instance_count", + "Required": true + }, + { + "ROS": "MseVersion", + "Terraform": "mse_version", + "Required": false + }, + { + "ROS": "NetType", + "Terraform": "net_type", + "Required": true + }, + { + "ROS": null, + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": "PrivateSlbSpecification", + "Terraform": "private_slb_specification", + "Required": false + }, + { + "ROS": "PubNetworkFlow", + "Terraform": "pub_network_flow", + "Required": false + }, + { + "ROS": "PubSlbSpecification", + "Terraform": "pub_slb_specification", + "Required": false + }, + { + "ROS": "RequestPars", + "Terraform": "request_pars", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Attributes": [ + { + "ROS": "AclEntryList", + "Terraform": null + }, + { + "ROS": "AclId", + "Terraform": null + }, + { + "ROS": "AppVersion", + "Terraform": "app_version" + }, + { + "ROS": "ClusterAliasName", + "Terraform": null + }, + { + "ROS": "ClusterId", + "Terraform": "cluster_id" + }, + { + "ROS": "ClusterName", + "Terraform": null + }, + { + "ROS": "ClusterSpecification", + "Terraform": null + }, + { + "ROS": "ClusterType", + "Terraform": null + }, + { + "ROS": "ClusterVersion", + "Terraform": null + }, + { + "ROS": "ConfigAuthEnabled", + "Terraform": null + }, + { + "ROS": "ConfigSecretEnabled", + "Terraform": null + }, + { + "ROS": "ConnectionType", + "Terraform": null + }, + { + "ROS": "Cpu", + "Terraform": null + }, + { + "ROS": "DiskCapacity", + "Terraform": null + }, + { + "ROS": "DiskType", + "Terraform": null + }, + { + "ROS": "HealthStatus", + "Terraform": null + }, + { + "ROS": "ClusterId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "InstanceCount", + "Terraform": null + }, + { + "ROS": "InstanceId", + "Terraform": null + }, + { + "ROS": "InternetAddress", + "Terraform": null + }, + { + "ROS": "InternetDomain", + "Terraform": null + }, + { + "ROS": "InternetPort", + "Terraform": null + }, + { + "ROS": "IntranetAddress", + "Terraform": null + }, + { + "ROS": "IntranetDomain", + "Terraform": null + }, + { + "ROS": "IntranetPort", + "Terraform": null + }, + { + "ROS": "MCPEnabled", + "Terraform": null + }, + { + "ROS": "MemoryCapacity", + "Terraform": null + }, + { + "ROS": "MseVersion", + "Terraform": null + }, + { + "ROS": "NetType", + "Terraform": null + }, + { + "ROS": "PayInfo", + "Terraform": null + }, + { + "ROS": "PubNetworkFlow", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "VpcId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::MSE::EngineNamespace", + "Terraform": "alicloud_mse_engine_namespace" + }, + "ProductCode": "mse", + "Name": { + "zh": "MSE EngineNamespace", + "en": "MSE Engine Namespace" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "accept_language", + "Required": false + }, + { + "ROS": null, + "Terraform": "cluster_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::MSE::Cluster" + } + ] + }, + { + "ROS": "Desc", + "Terraform": null, + "Required": false + }, + { + "ROS": "Id", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceId", + "Terraform": "instance_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::MSE::Cluster", + "SyncWith": "ROS/InstanceId" + } + ] + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": null, + "Terraform": "namespace_desc", + "Required": false + }, + { + "ROS": null, + "Terraform": "namespace_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "namespace_show_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "NamespaceId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::MSE::Gateway", + "Terraform": "alicloud_mse_gateway" + }, + "ProductCode": "mse", + "Name": { + "zh": "MSE网关", + "en": "MSE Gateway" + }, + "Properties": [ + { + "ROS": "BackupVSwitchId", + "Terraform": "backup_vswitch_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "delete_slb", + "Required": false + }, + { + "ROS": "EnterpriseSecurityGroup", + "Terraform": "enterprise_security_group", + "Required": false + }, + { + "ROS": null, + "Terraform": "gateway_name", + "Required": false + }, + { + "ROS": "InternetSlbSpec", + "Terraform": "internet_slb_spec", + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": false + }, + { + "ROS": "Replica", + "Terraform": "replica", + "Required": true + }, + { + "ROS": "SlbSpec", + "Terraform": "slb_spec", + "Required": false + }, + { + "ROS": "Spec", + "Terraform": "spec", + "Required": true + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Attributes": [ + { + "ROS": "BackupVSwitchId", + "Terraform": null + }, + { + "ROS": "GatewayUniqueId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "PaymentType", + "Terraform": null + }, + { + "ROS": "Replica", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "slb_list" + }, + { + "ROS": "Spec", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "VpcId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::MSE::NacosConfig", + "Terraform": null + }, + "ProductCode": "mse", + "Name": { + "zh": "MSE Nacos配置", + "en": "MSE Nacos Configuration" + }, + "Properties": [ + { + "ROS": "AppName", + "Terraform": null, + "Required": false + }, + { + "ROS": "BetaIps", + "Terraform": null, + "Required": false + }, + { + "ROS": "Content", + "Terraform": null, + "Required": false + }, + { + "ROS": "DataId", + "Terraform": null, + "Required": true + }, + { + "ROS": "Desc", + "Terraform": null, + "Required": false + }, + { + "ROS": "Group", + "Terraform": null, + "Required": true + }, + { + "ROS": "InstanceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::MSE::Cluster", + "SyncWith": "ROS/InstanceId" + } + ] + }, + { + "ROS": "NamespaceId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::MSE::EngineNamespace" + } + ] + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false + }, + { + "ROS": "Type", + "Terraform": null, + "Required": false + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::MSE::NacosService", + "Terraform": null + }, + "ProductCode": "mse", + "Name": { + "zh": "MSE Nacos服务", + "en": "MSE Nacos Service" + }, + "Properties": [ + { + "ROS": "Ephemeral", + "Terraform": null, + "Required": false + }, + { + "ROS": "GroupName", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::MSE::Cluster", + "SyncWith": "ROS/InstanceId" + } + ] + }, + { + "ROS": "NamespaceId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::MSE::EngineNamespace" + } + ] + }, + { + "ROS": "ProtectThreshold", + "Terraform": null, + "Required": false + }, + { + "ROS": "ServiceName", + "Terraform": null, + "Required": true + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::MSE::ServiceSource", + "Terraform": null + }, + "ProductCode": "mse", + "Name": { + "zh": "MSE ServiceSource", + "en": "MSE Service Source" + }, + "Properties": [ + { + "ROS": "Address", + "Terraform": null, + "Required": false + }, + { + "ROS": "GatewayUniqueId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::MSE::Gateway" + } + ] + }, + { + "ROS": "GroupList", + "Terraform": null, + "Required": false + }, + { + "ROS": "IngressOptions", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "EnableIngress", + "Terraform": null, + "Required": false + }, + { + "ROS": "EnableStatus", + "Terraform": null, + "Required": false + }, + { + "ROS": "IngressClass", + "Terraform": null, + "Required": false + }, + { + "ROS": "WatchNamespace", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "PathList", + "Terraform": null, + "Required": false + }, + { + "ROS": "Source", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "Address", + "Terraform": null + }, + { + "ROS": "GatewayUniqueId", + "Terraform": null + }, + { + "ROS": "Id", + "Terraform": null + }, + { + "ROS": "Name", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::MarketPlace::Order", + "Terraform": "alicloud_market_order" + }, + "ProductCode": "marketplace", + "Name": { + "zh": "MarketPlace Order", + "en": "Marketplace Order" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "components", + "Required": false + }, + { + "ROS": null, + "Terraform": "coupon_id", + "Required": false + }, + { + "ROS": "Duration", + "Terraform": "duration", + "Required": false + }, + { + "ROS": "SkuCode", + "Terraform": "package_version", + "Required": true + }, + { + "ROS": "ChargeType", + "Terraform": "pay_type", + "Required": false + }, + { + "ROS": "Preference", + "Terraform": null, + "Required": false + }, + { + "ROS": "PricingCycle", + "Terraform": "pricing_cycle", + "Required": false + }, + { + "ROS": "ProductCode", + "Terraform": "product_code", + "Required": true + }, + { + "ROS": "Quantity", + "Terraform": "quantity", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "OrderId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::MaxCompute::Package", + "Terraform": null + }, + "ProductCode": "odps", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "Acl", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Function", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Actions", + "Terraform": null, + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "Resource", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Actions", + "Terraform": null, + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "Table", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Actions", + "Terraform": null, + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + } + ] + }, + { + "ROS": "PackageName", + "Terraform": null, + "Required": true + }, + { + "ROS": "ProjectName", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::MaxCompute::Project" + } + ] + } + ], + "Attributes": [ + { + "ROS": "PackageName", + "Terraform": null + }, + { + "ROS": "ProjectName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::MaxCompute::Project", + "Terraform": "alicloud_maxcompute_project" + }, + "ProductCode": "odps", + "Name": { + "zh": "MaxCompute Project", + "en": "MaxCompute Project" + }, + "Properties": [ + { + "ROS": "ChargeType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Comment", + "Terraform": "comment", + "Required": false + }, + { + "ROS": "DefaultQuota", + "Terraform": "default_quota", + "Required": false + }, + { + "ROS": "IpWhiteList", + "Terraform": "ip_white_list", + "Required": false + }, + { + "ROS": null, + "Terraform": "is_logical", + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": null, + "Terraform": "product_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "project_name", + "Required": false + }, + { + "ROS": "Properties", + "Terraform": "properties", + "Required": false + }, + { + "ROS": null, + "Terraform": "security_properties", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "ProjectName", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "Name", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "owner" + }, + { + "ROS": null, + "Terraform": "type" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::MaxCompute::Role", + "Terraform": null + }, + "ProductCode": "odps", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "Acl", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Function", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Actions", + "Terraform": null, + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "Instance", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Actions", + "Terraform": null, + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "Package", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Actions", + "Terraform": null, + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "Project", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Actions", + "Terraform": null, + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "Resource", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Actions", + "Terraform": null, + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "Table", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Actions", + "Terraform": null, + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + } + ] + }, + { + "ROS": "Policy", + "Terraform": null, + "Required": false + }, + { + "ROS": "ProjectName", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::MaxCompute::Project" + } + ] + }, + { + "ROS": "RoleName", + "Terraform": null, + "Required": true + }, + { + "ROS": "Type", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "ProjectName", + "Terraform": null + }, + { + "ROS": "RoleName", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::MaxCompute::Table", + "Terraform": null + }, + "ProductCode": "odps", + "Name": { + "zh": "MaxCompute表", + "en": "MaxCompute Table" + }, + "Properties": [ + { + "ROS": "Comment", + "Terraform": null, + "Required": false + }, + { + "ROS": "IfNotExists", + "Terraform": null, + "Required": false + }, + { + "ROS": "Lifecycle", + "Terraform": null, + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "Project", + "Terraform": null, + "Required": true + }, + { + "ROS": "Schema", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Columns", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "Comment", + "Terraform": null, + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "Type", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "Partitions", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Comment", + "Terraform": null, + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "Type", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + } + ] + }, + { + "ROS": "StringSchema", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Name", + "Terraform": null + }, + { + "ROS": "Project", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::Memcache::Instance", + "Terraform": null + }, + "ProductCode": "ocs", + "Name": { + "zh": "Memcache实例", + "en": "ApsaraDB for Memcache Instance" + }, + "Properties": [ + { + "ROS": "AutoRenew", + "Terraform": null, + "Required": false + }, + { + "ROS": "AutoRenewPeriod", + "Terraform": null, + "Required": false + }, + { + "ROS": "AutoUseCoupon", + "Terraform": null, + "Required": false + }, + { + "ROS": "BackupPolicy", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "EnableBackupLog", + "Terraform": null, + "Required": false + }, + { + "ROS": "PreferredBackupPeriod", + "Terraform": null, + "Required": true + }, + { + "ROS": "PreferredBackupTime", + "Terraform": null, + "Required": true + } + ] + }, + { + "ROS": "Capacity", + "Terraform": null, + "Required": false + }, + { + "ROS": "ChargeType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Config", + "Terraform": null, + "Required": false + }, + { + "ROS": "CouponNo", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceClass", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceName", + "Terraform": null, + "Required": false + }, + { + "ROS": "NetworkType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Password", + "Terraform": null, + "Required": false + }, + { + "ROS": "Period", + "Terraform": null, + "Required": false + }, + { + "ROS": "PrivateIpAddress", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "VpcId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VpcPasswordFree", + "Terraform": null, + "Required": false + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "ZoneId", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "ConnectionDomain", + "Terraform": null + }, + { + "ROS": "InstanceId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "InstanceName", + "Terraform": null + }, + { + "ROS": "Port", + "Terraform": null + }, + { + "ROS": "QPS", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::Memcache::Whitelist", + "Terraform": null + }, + "ProductCode": "ocs", + "Name": { + "zh": "Memcache白名单", + "en": "ApsaraDB for Memcache Whitelist" + }, + "Properties": [ + { + "ROS": "InstanceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::Memcache::Instance" + } + ] + }, + { + "ROS": "SecurityIpGroupAttribute", + "Terraform": null, + "Required": false + }, + { + "ROS": "SecurityIpGroupName", + "Terraform": null, + "Required": false + }, + { + "ROS": "SecurityIps", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "SecurityIpGroupAttribute", + "Terraform": null + }, + { + "ROS": "SecurityIpGroupName", + "Terraform": null + }, + { + "ROS": "SecurityIps", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::NLB::BackendServerAttachment", + "Terraform": null + }, + "ProductCode": "nlb", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "ServerGroupId", + "Terraform": null, + "Required": true + }, + { + "ROS": "Servers", + "Terraform": null, + "Required": true, + "Type": "list", + "Properties": [ + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "Port", + "Terraform": null, + "Required": false + }, + { + "ROS": "ServerId", + "Terraform": null, + "Required": true + }, + { + "ROS": "ServerIp", + "Terraform": null, + "Required": false + }, + { + "ROS": "ServerType", + "Terraform": null, + "Required": true + }, + { + "ROS": "Weight", + "Terraform": null, + "Required": false + } + ] + } + ], + "Attributes": [ + { + "ROS": "ServerGroupId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::NLB::Listener", + "Terraform": "alicloud_nlb_listener" + }, + "ProductCode": "nlb", + "Name": { + "zh": "NLB监听", + "en": "NLB Listener" + }, + "Properties": [ + { + "ROS": "AlpnEnabled", + "Terraform": "alpn_enabled", + "Required": false + }, + { + "ROS": "AlpnPolicy", + "Terraform": "alpn_policy", + "Required": false + }, + { + "ROS": "CaCertificateIds", + "Terraform": "ca_certificate_ids", + "Required": false + }, + { + "ROS": "CaEnabled", + "Terraform": "ca_enabled", + "Required": false + }, + { + "ROS": "CertificateIds", + "Terraform": "certificate_ids", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CAS::Certificate" + } + ] + }, + { + "ROS": "Cps", + "Terraform": "cps", + "Required": false + }, + { + "ROS": "Enable", + "Terraform": null, + "Required": false + }, + { + "ROS": "EndPort", + "Terraform": "end_port", + "Required": false + }, + { + "ROS": "IdleTimeout", + "Terraform": "idle_timeout", + "Required": false + }, + { + "ROS": "ListenerDescription", + "Terraform": "listener_description", + "Required": false + }, + { + "ROS": "ListenerPort", + "Terraform": "listener_port", + "Required": false + }, + { + "ROS": "ListenerProtocol", + "Terraform": "listener_protocol", + "Required": true + }, + { + "ROS": "LoadBalancerId", + "Terraform": "load_balancer_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::NLB::LoadBalancer" + } + ] + }, + { + "ROS": "Mss", + "Terraform": "mss", + "Required": false + }, + { + "ROS": "ProxyProtocolEnabled", + "Terraform": "proxy_protocol_enabled", + "Required": false + }, + { + "ROS": "ProxyProtocolV2Config", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Ppv2PrivateLinkEpIdEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "Ppv2PrivateLinkEpsIdEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "Ppv2VpcIdEnabled", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "SecSensorEnabled", + "Terraform": "sec_sensor_enabled", + "Required": false + }, + { + "ROS": "SecurityPolicyId", + "Terraform": "security_policy_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::NLB::SecurityPolicy" + } + ] + }, + { + "ROS": "ServerGroupId", + "Terraform": "server_group_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::NLB::ServerGroup" + } + ] + }, + { + "ROS": "StartPort", + "Terraform": "start_port", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "ListenerId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "ListenerPort", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::NLB::LoadBalancer", + "Terraform": "alicloud_nlb_load_balancer" + }, + "ProductCode": "nlb", + "Name": { + "zh": "网络型负载均衡NLB", + "en": "NLB Instance" + }, + "Properties": [ + { + "ROS": "AddressIpVersion", + "Terraform": "address_ip_version", + "Required": false + }, + { + "ROS": "AddressType", + "Terraform": "address_type", + "Required": true + }, + { + "ROS": "BandwidthPackageId", + "Terraform": "bandwidth_package_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::CommonBandwidthPackage" + } + ] + }, + { + "ROS": "CrossZoneEnabled", + "Terraform": "cross_zone_enabled", + "Required": false + }, + { + "ROS": "DeletionProtectionConfig", + "Terraform": "deletion_protection_config", + "Required": false + }, + { + "ROS": null, + "Terraform": "ipv6_address_type", + "Required": false + }, + { + "ROS": "LoadBalancerBillingConfig", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "PayType", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "LoadBalancerName", + "Terraform": "load_balancer_name", + "Required": false + }, + { + "ROS": "LoadBalancerType", + "Terraform": "load_balancer_type", + "Required": false + }, + { + "ROS": "ModificationProtectionConfig", + "Terraform": "modification_protection_config", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "security_group_ids", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "TrafficAffinityEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "ZoneMappings", + "Terraform": "zone_mappings", + "Required": true, + "Properties": [ + { + "ROS": "AllocationId", + "Terraform": "allocation_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "private_ipv4_address", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": null, + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "ZoneId", + "Terraform": "zone_id", + "Required": true + } + ], + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "AddressIpVersion", + "Terraform": null + }, + { + "ROS": "AddressType", + "Terraform": null + }, + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "deletion_protection_config" + }, + { + "ROS": "DNSName", + "Terraform": "dns_name" + }, + { + "ROS": "LoadBalancerId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "load_balancer_business_status" + }, + { + "ROS": "LoadBalancerType", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "modification_protection_config" + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "VpcId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "ZoneMappings", + "Terraform": "zone_mappings" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::NLB::SecurityGroupAttachment", + "Terraform": "alicloud_nlb_load_balancer_security_group_attachment" + }, + "ProductCode": "nlb", + "Name": { + "zh": "绑定安全组", + "en": "Associate Security Group" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": "LoadBalancerId", + "Terraform": "load_balancer_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::NLB::LoadBalancer" + } + ] + }, + { + "ROS": null, + "Terraform": "port", + "Required": false + }, + { + "ROS": null, + "Terraform": "security_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "SecurityGroupIds", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "server_group_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "server_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "server_ip", + "Required": false + }, + { + "ROS": null, + "Terraform": "server_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "weight", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": null, + "Terraform": "zone_id" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::NLB::SecurityPolicy", + "Terraform": "alicloud_nlb_security_policy" + }, + "ProductCode": "nlb", + "Name": { + "zh": "NLB安全策略", + "en": "NLB Security Policy" + }, + "Properties": [ + { + "ROS": "Ciphers", + "Terraform": "ciphers", + "Required": true + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "SecurityPolicyName", + "Terraform": "security_policy_name", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "TlsVersions", + "Terraform": "tls_versions", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": "SecurityPolicyId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::NLB::ServerGroup", + "Terraform": "alicloud_nlb_server_group" + }, + "ProductCode": "nlb", + "Name": { + "zh": "NLB服务器组", + "en": "NLB Server Group" + }, + "Properties": [ + { + "ROS": "AddressIPVersion", + "Terraform": "address_ip_version", + "Required": false + }, + { + "ROS": "AnyPortEnabled", + "Terraform": "any_port_enabled", + "Required": false + }, + { + "ROS": "ConnectionDrainEnabled", + "Terraform": "connection_drain_enabled", + "Required": false + }, + { + "ROS": "ConnectionDrainTimeout", + "Terraform": "connection_drain_timeout", + "Required": false + }, + { + "ROS": null, + "Terraform": "health_check", + "Required": false + }, + { + "ROS": "HealthCheckConfig", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "HealthCheckConnectPort", + "Terraform": null, + "Required": false + }, + { + "ROS": "HealthCheckConnectTimeout", + "Terraform": null, + "Required": false + }, + { + "ROS": "HealthCheckDomain", + "Terraform": null, + "Required": false + }, + { + "ROS": "HealthCheckEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "HealthCheckHttpCode", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "HealthCheckInterval", + "Terraform": null, + "Required": false + }, + { + "ROS": "HealthCheckType", + "Terraform": null, + "Required": false + }, + { + "ROS": "HealthCheckUrl", + "Terraform": null, + "Required": false + }, + { + "ROS": "HealthyThreshold", + "Terraform": null, + "Required": false + }, + { + "ROS": "HttpCheckMethod", + "Terraform": null, + "Required": true + }, + { + "ROS": "UnhealthyThreshold", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "PersistenceEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "PersistenceTimeout", + "Terraform": null, + "Required": false + }, + { + "ROS": "PreserveClientIpEnabled", + "Terraform": "preserve_client_ip_enabled", + "Required": false + }, + { + "ROS": "Protocol", + "Terraform": "protocol", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "Scheduler", + "Terraform": "scheduler", + "Required": false + }, + { + "ROS": "ServerGroupName", + "Terraform": "server_group_name", + "Required": true + }, + { + "ROS": "ServerGroupType", + "Terraform": "server_group_type", + "Required": false + }, + { + "ROS": "Servers", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "Port", + "Terraform": null, + "Required": false + }, + { + "ROS": "ServerId", + "Terraform": null, + "Required": true + }, + { + "ROS": "ServerIp", + "Terraform": null, + "Required": false + }, + { + "ROS": "ServerType", + "Terraform": null, + "Required": true + }, + { + "ROS": "Weight", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ], + "Attributes": [ + { + "ROS": "ServerGroupId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::NLPAUTOML::Dataset", + "Terraform": null + }, + "ProductCode": "nlp", + "Name": { + "zh": "NLPAUTOML Dataset", + "en": "NLP Dataset" + }, + "Properties": [ + { + "ROS": "DatasetName", + "Terraform": null, + "Required": true + }, + { + "ROS": "DatasetRecord", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "ProjectId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::NLPAUTOML::Project" + } + ] + } + ], + "Attributes": [ + { + "ROS": "DatasetId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::NLPAUTOML::Model", + "Terraform": null + }, + "ProductCode": "nlp", + "Name": { + "zh": "NLPAUTOML Model", + "en": "NLP Model" + }, + "Properties": [ + { + "ROS": "DatasetIdList", + "Terraform": null, + "Required": true, + "Properties": {}, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::NLPAUTOML::Dataset" + } + ], + "Type": "list" + }, + { + "ROS": "Lr", + "Terraform": null, + "Required": false + }, + { + "ROS": "ModelName", + "Terraform": null, + "Required": true + }, + { + "ROS": "ModelType", + "Terraform": null, + "Required": true + }, + { + "ROS": "Nepochs", + "Terraform": null, + "Required": false + }, + { + "ROS": "ProjectId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::NLPAUTOML::Project" + } + ] + }, + { + "ROS": "TestDatasetIdList", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "ModelId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "ModelVersion", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::NLPAUTOML::Project", + "Terraform": null + }, + "ProductCode": "nlp", + "Name": { + "zh": "NLPAUTOML Project", + "en": "NLP Project" + }, + "Properties": [ + { + "ROS": "ProjectDescription", + "Terraform": null, + "Required": true + }, + { + "ROS": "ProjectName", + "Terraform": null, + "Required": true + }, + { + "ROS": "ProjectType", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "ProjectId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::NLS::Project", + "Terraform": null + }, + "ProductCode": "nls", + "Name": { + "zh": "NLS Project", + "en": "NLS Project" + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "ProjectType", + "Terraform": null, + "Required": false + }, + { + "ROS": "SdkType", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "AppKey", + "Terraform": null + }, + { + "ROS": "ProjectId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::OTS::Instance", + "Terraform": "alicloud_ots_instance" + }, + "ProductCode": "ots", + "Name": { + "zh": "OTS实例", + "en": "Tablestore Instance" + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "ClusterType", + "Terraform": "instance_type", + "Required": false + }, + { + "ROS": "InstanceName", + "Terraform": "name", + "Required": true + }, + { + "ROS": "Network", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "network_source_acl", + "Required": false + }, + { + "ROS": null, + "Terraform": "network_type_acl", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "InstanceName", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "PrivateEndpoint", + "Terraform": null + }, + { + "ROS": "PublicEndpoint", + "Terraform": null + }, + { + "ROS": "VpcEndpoint", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::OTS::SearchIndex", + "Terraform": "alicloud_ots_search_index" + }, + "ProductCode": "ots", + "Name": { + "zh": "OTS多元索引", + "en": "Tablestore Search Index" + }, + "Properties": [ + { + "ROS": "FieldSchemas", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "Analyzer", + "Terraform": null, + "Required": false + }, + { + "ROS": "EnableSortAndAgg", + "Terraform": null, + "Required": false + }, + { + "ROS": "FieldName", + "Terraform": null, + "Required": true + }, + { + "ROS": "FieldType", + "Terraform": null, + "Required": true + }, + { + "ROS": "Index", + "Terraform": null, + "Required": false + }, + { + "ROS": "IsArray", + "Terraform": null, + "Required": false + }, + { + "ROS": "Store", + "Terraform": null, + "Required": false + }, + { + "ROS": "SubFieldSchemas", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Analyzer", + "Terraform": null, + "Required": false + }, + { + "ROS": "EnableSortAndAgg", + "Terraform": null, + "Required": false + }, + { + "ROS": "FieldName", + "Terraform": null, + "Required": true + }, + { + "ROS": "FieldType", + "Terraform": null, + "Required": true + }, + { + "ROS": "Index", + "Terraform": null, + "Required": false + }, + { + "ROS": "IsArray", + "Terraform": null, + "Required": false + }, + { + "ROS": "Store", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + } + ], + "Type": "list" + }, + { + "ROS": "IndexName", + "Terraform": "index_name", + "Required": true + }, + { + "ROS": "IndexSetting", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "RoutingFields", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "IndexSort", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Sorters", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "FieldSort", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "FieldName", + "Terraform": null, + "Required": true + }, + { + "ROS": "SortMode", + "Terraform": null, + "Required": false + }, + { + "ROS": "SortOrder", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "GeoDistanceSort", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "FieldName", + "Terraform": null, + "Required": true + }, + { + "ROS": "Points", + "Terraform": null, + "Required": true + }, + { + "ROS": "SortMode", + "Terraform": null, + "Required": false + }, + { + "ROS": "SortOrder", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "PrimaryKeySort", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "SortOrder", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "ScoreSort", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "SortOrder", + "Terraform": null, + "Required": false + } + ] + } + ], + "Type": "list" + } + ] + }, + { + "ROS": "InstanceName", + "Terraform": "instance_name", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::OTS::Instance" + } + ] + }, + { + "ROS": null, + "Terraform": "schema", + "Required": false, + "Properties": [ + { + "ROS": "FieldSchemas", + "Terraform": "field_schema", + "Required": false, + "Properties": [ + { + "ROS": "Analyzer", + "Terraform": "analyzer", + "Required": false + }, + { + "ROS": "EnableSortAndAgg", + "Terraform": "enable_sort_and_agg", + "Required": false + }, + { + "ROS": "FieldName", + "Terraform": "field_name", + "Required": false + }, + { + "ROS": "FieldType", + "Terraform": "field_type", + "Required": false + }, + { + "ROS": "Index", + "Terraform": "index", + "Required": false + }, + { + "ROS": "IsArray", + "Terraform": "is_array", + "Required": false + }, + { + "ROS": "Store", + "Terraform": "store", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "IndexSetting", + "Terraform": "index_setting", + "Required": false, + "Properties": [ + { + "ROS": "RoutingFields", + "Terraform": "routing_fields", + "Required": false + } + ] + }, + { + "ROS": "IndexSort", + "Terraform": "index_sort", + "Required": false, + "Properties": [ + { + "ROS": "Sorters", + "Terraform": "sorter", + "Required": false + } + ] + } + ] + }, + { + "ROS": "TableName", + "Terraform": "table_name", + "Required": true + }, + { + "ROS": null, + "Terraform": "time_to_live", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "current_sync_timestamp" + }, + { + "ROS": "IndexName", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "index_id" + }, + { + "ROS": "IndexName", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "sync_phase" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::OTS::Table", + "Terraform": "alicloud_ots_table" + }, + "ProductCode": "ots", + "Name": { + "zh": "OTS表", + "en": "Tablestore Table" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "allow_update", + "Required": false + }, + { + "ROS": "Columns", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "Type", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": null, + "Terraform": "defined_column", + "Required": false + }, + { + "ROS": "DeviationCellVersionInSec", + "Terraform": "deviation_cell_version_in_sec", + "Required": false + }, + { + "ROS": null, + "Terraform": "enable_sse", + "Required": false + }, + { + "ROS": "InstanceName", + "Terraform": "instance_name", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::OTS::Instance" + } + ] + }, + { + "ROS": "MaxVersions", + "Terraform": "max_version", + "Required": false + }, + { + "ROS": "PrimaryKey", + "Terraform": "primary_key", + "Required": true, + "Properties": [ + { + "ROS": "Name", + "Terraform": "name", + "Required": true + }, + { + "ROS": "Type", + "Terraform": "type", + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "ReservedThroughput", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Read", + "Terraform": null, + "Required": true + }, + { + "ROS": "Write", + "Terraform": null, + "Required": true + } + ] + }, + { + "ROS": "SecondaryIndices", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Columns", + "Terraform": null, + "Required": true, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "IndexName", + "Terraform": null, + "Required": true + }, + { + "ROS": "IndexType", + "Terraform": null, + "Required": false + }, + { + "ROS": "PrimaryKeys", + "Terraform": null, + "Required": true, + "Properties": {}, + "Type": "list" + } + ], + "Type": "list" + }, + { + "ROS": null, + "Terraform": "sse_key_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "sse_key_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "sse_role_arn", + "Required": false + }, + { + "ROS": "TableName", + "Terraform": "table_name", + "Required": true + }, + { + "ROS": "TimeToLive", + "Terraform": "time_to_live", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "TableName", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "TableName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::OTS::VpcBinder", + "Terraform": null + }, + "ProductCode": "ots", + "Name": { + "zh": "OTS绑定专有网络", + "en": "Associate Tablestore with VPC" + }, + "Properties": [ + { + "ROS": "InstanceName", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::OTS::Instance" + } + ] + }, + { + "ROS": "Vpcs", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ], + "Properties": [ + { + "ROS": "InstanceVpcName", + "Terraform": null, + "Required": true + }, + { + "ROS": "Network", + "Terraform": null, + "Required": true + }, + { + "ROS": "VirtualSwitchId", + "Terraform": null, + "Required": true + }, + { + "ROS": "VpcId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ], + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "Domains", + "Terraform": null + }, + { + "ROS": "Endpoints", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::PAI::CodeSource", + "Terraform": null + }, + "ProductCode": "learn", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "Accessibility", + "Terraform": null, + "Required": true + }, + { + "ROS": "CodeBranch", + "Terraform": null, + "Required": false + }, + { + "ROS": "CodeCommit", + "Terraform": null, + "Required": false + }, + { + "ROS": "CodeRepo", + "Terraform": null, + "Required": true + }, + { + "ROS": "CodeRepoAccessToken", + "Terraform": null, + "Required": false + }, + { + "ROS": "CodeRepoUserName", + "Terraform": null, + "Required": false + }, + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "DisplayName", + "Terraform": null, + "Required": true + }, + { + "ROS": "MountPath", + "Terraform": null, + "Required": true + }, + { + "ROS": "WorkspaceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::PAI::Workspace" + } + ] + } + ], + "Attributes": [ + { + "ROS": "Accessibility", + "Terraform": null + }, + { + "ROS": "CodeBranch", + "Terraform": null + }, + { + "ROS": "CodeCommit", + "Terraform": null + }, + { + "ROS": "CodeRepo", + "Terraform": null + }, + { + "ROS": "CodeRepoAccessToken", + "Terraform": null + }, + { + "ROS": "CodeRepoUserName", + "Terraform": null + }, + { + "ROS": "CodeSourcesId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "CreateTime", + "Terraform": null + }, + { + "ROS": "Description", + "Terraform": null + }, + { + "ROS": "DisplayName", + "Terraform": null + }, + { + "ROS": "GmtModifyTime", + "Terraform": null + }, + { + "ROS": "MountPath", + "Terraform": null + }, + { + "ROS": "UserId", + "Terraform": null + }, + { + "ROS": "WorkspaceId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::PAI::Dataset", + "Terraform": null + }, + "ProductCode": "learn", + "Name": { + "zh": "PAI Dataset", + "en": "PAI Dataset" + }, + "Properties": [ + { + "ROS": "Accessibility", + "Terraform": null, + "Required": false + }, + { + "ROS": "DatasetName", + "Terraform": null, + "Required": true + }, + { + "ROS": "DataSourceType", + "Terraform": null, + "Required": true + }, + { + "ROS": "DataType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "Options", + "Terraform": null, + "Required": false + }, + { + "ROS": "Property", + "Terraform": null, + "Required": true + }, + { + "ROS": "SourceId", + "Terraform": null, + "Required": false + }, + { + "ROS": "SourceType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Uri", + "Terraform": null, + "Required": true + }, + { + "ROS": "WorkspaceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::PAI::Workspace" + } + ] + } + ], + "Attributes": [ + { + "ROS": "Accessibility", + "Terraform": null + }, + { + "ROS": "CreateTime", + "Terraform": null + }, + { + "ROS": "DatasetId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "DatasetName", + "Terraform": null + }, + { + "ROS": "DataSourceType", + "Terraform": null + }, + { + "ROS": "DataType", + "Terraform": null + }, + { + "ROS": "Description", + "Terraform": null + }, + { + "ROS": "GmtModifiedTime", + "Terraform": null + }, + { + "ROS": "Options", + "Terraform": null + }, + { + "ROS": "OwnerId", + "Terraform": null + }, + { + "ROS": "Property", + "Terraform": null + }, + { + "ROS": "SourceId", + "Terraform": null + }, + { + "ROS": "SourceType", + "Terraform": null + }, + { + "ROS": "Uri", + "Terraform": null + }, + { + "ROS": "UserId", + "Terraform": null + }, + { + "ROS": "WorkspaceId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::PAI::Workspace" + } + ] + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::PAI::DatasetVersion", + "Terraform": null + }, + "ProductCode": "learn", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "DataCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "DatasetId", + "Terraform": null, + "Required": true + }, + { + "ROS": "DataSize", + "Terraform": null, + "Required": false + }, + { + "ROS": "DataSourceType", + "Terraform": null, + "Required": true + }, + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "Labels", + "Terraform": null, + "Required": false, + "Type": "list", + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "Options", + "Terraform": null, + "Required": false + }, + { + "ROS": "Property", + "Terraform": null, + "Required": true + }, + { + "ROS": "SourceId", + "Terraform": null, + "Required": false + }, + { + "ROS": "SourceType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Uri", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "VersionName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::PAI::Experiment", + "Terraform": null + }, + "ProductCode": "learn", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "Accessibility", + "Terraform": null, + "Required": false + }, + { + "ROS": "ArtifactUri", + "Terraform": null, + "Required": true + }, + { + "ROS": "ExperimentName", + "Terraform": null, + "Required": true + }, + { + "ROS": "WorkspaceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::PAI::Workspace" + } + ] + } + ], + "Attributes": [ + { + "ROS": "Accessibility", + "Terraform": null + }, + { + "ROS": "ArtifactUri", + "Terraform": null + }, + { + "ROS": "CreateTime", + "Terraform": null + }, + { + "ROS": "ExperimentId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "ExperimentName", + "Terraform": null + }, + { + "ROS": "GmtModifiedTime", + "Terraform": null + }, + { + "ROS": "Labels", + "Terraform": null + }, + { + "ROS": "OwnerId", + "Terraform": null + }, + { + "ROS": "TensorboardLogUri", + "Terraform": null + }, + { + "ROS": "UserId", + "Terraform": null + }, + { + "ROS": "WorkspaceId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::PAI::Run", + "Terraform": null + }, + "ProductCode": "learn", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "ExperimentId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::PAI::Experiment" + } + ] + }, + { + "ROS": "RunName", + "Terraform": null, + "Required": false + }, + { + "ROS": "SourceId", + "Terraform": null, + "Required": false + }, + { + "ROS": "SourceType", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Accessibility", + "Terraform": null + }, + { + "ROS": "CreateTime", + "Terraform": null + }, + { + "ROS": "ExperimentId", + "Terraform": null + }, + { + "ROS": "GmtModifiedTime", + "Terraform": null + }, + { + "ROS": "Labels", + "Terraform": null + }, + { + "ROS": "Metrics", + "Terraform": null + }, + { + "ROS": "OwnerId", + "Terraform": null + }, + { + "ROS": "Params", + "Terraform": null + }, + { + "ROS": "RunId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "RunName", + "Terraform": null + }, + { + "ROS": "SourceId", + "Terraform": null + }, + { + "ROS": "SourceType", + "Terraform": null + }, + { + "ROS": "UserId", + "Terraform": null + }, + { + "ROS": "WorkspaceId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::PAI::Service", + "Terraform": null + }, + "ProductCode": "learn", + "Name": { + "zh": "PAI Service", + "en": "PAI EAS Service" + }, + "Properties": [ + { + "ROS": "Develop", + "Terraform": null, + "Required": false + }, + { + "ROS": "Labels", + "Terraform": null, + "Required": false + }, + { + "ROS": "ServiceConfig", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "AccessToken", + "Terraform": null + }, + { + "ROS": "CallerUid", + "Terraform": null + }, + { + "ROS": "Cpu", + "Terraform": null + }, + { + "ROS": "CreateTime", + "Terraform": null + }, + { + "ROS": "CurrentVersion", + "Terraform": null + }, + { + "ROS": "ExtraData", + "Terraform": null + }, + { + "ROS": "Gpu", + "Terraform": null + }, + { + "ROS": "Image", + "Terraform": null + }, + { + "ROS": "InternetEndpoint", + "Terraform": null + }, + { + "ROS": "IntranetEndpoint", + "Terraform": null + }, + { + "ROS": "Labels", + "Terraform": null + }, + { + "ROS": "LatestVersion", + "Terraform": null + }, + { + "ROS": "Memory", + "Terraform": null + }, + { + "ROS": "Message", + "Terraform": null + }, + { + "ROS": "Namespace", + "Terraform": null + }, + { + "ROS": "ParentUid", + "Terraform": null + }, + { + "ROS": "PendingInstance", + "Terraform": null + }, + { + "ROS": "Reason", + "Terraform": null + }, + { + "ROS": "Resource", + "Terraform": null + }, + { + "ROS": "ResourceAlias", + "Terraform": null + }, + { + "ROS": "Role", + "Terraform": null + }, + { + "ROS": "RoleAttrs", + "Terraform": null + }, + { + "ROS": "RunningInstance", + "Terraform": null + }, + { + "ROS": "SafetyLock", + "Terraform": null + }, + { + "ROS": "ServiceConfig", + "Terraform": null + }, + { + "ROS": "ServiceGroup", + "Terraform": null + }, + { + "ROS": "ServiceName", + "Terraform": null, + "Primary": true + }, + { + "ROS": "ServiceUid", + "Terraform": null + }, + { + "ROS": "TotalInstance", + "Terraform": null + }, + { + "ROS": "UpdateTime", + "Terraform": null + }, + { + "ROS": "Weight", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::PAI::Workspace", + "Terraform": null + }, + "ProductCode": "learn", + "Name": { + "zh": "PAI Workspace", + "en": "PAI Workspace" + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": null, + "Required": true + }, + { + "ROS": "DisplayName", + "Terraform": null, + "Required": false + }, + { + "ROS": "EnvTypes", + "Terraform": null, + "Required": true, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "WorkspaceName", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "AdminNames", + "Terraform": null + }, + { + "ROS": "Creator", + "Terraform": null + }, + { + "ROS": "Description", + "Terraform": null + }, + { + "ROS": "DisplayName", + "Terraform": null + }, + { + "ROS": "EnvTypes", + "Terraform": null + }, + { + "ROS": "ExtraInfos", + "Terraform": null + }, + { + "ROS": "Owner", + "Terraform": null + }, + { + "ROS": "Users", + "Terraform": null + }, + { + "ROS": "WorkspaceId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "WorkspaceName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::PAI::WorkspaceResourceDlc", + "Terraform": null + }, + "ProductCode": "learn", + "Name": { + "zh": "PAI WorkspaceResourceDlc", + "en": "PAI Workspace Resource DLC" + }, + "Properties": [ + { + "ROS": "GroupName", + "Terraform": null, + "Required": true + }, + { + "ROS": "IsDefault", + "Terraform": null, + "Required": false + }, + { + "ROS": "Option", + "Terraform": null, + "Required": false + }, + { + "ROS": "Resources", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "EnvType", + "Terraform": null, + "Required": true + }, + { + "ROS": "Spec", + "Terraform": null, + "Required": false + }, + { + "ROS": "WorkspaceResourceName", + "Terraform": null, + "Required": true + }, + { + "ROS": "WorkspaceResourceWorkspaceId", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "WorkspaceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::PAI::Workspace" + } + ] + } + ], + "Attributes": [ + { + "ROS": "CreateTime", + "Terraform": null + }, + { + "ROS": "GroupName", + "Terraform": null + }, + { + "ROS": "IsDefault", + "Terraform": null + }, + { + "ROS": "Resources", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::PAI::WorkspaceResourceFlink", + "Terraform": null + }, + "ProductCode": "learn", + "Name": { + "zh": "PAI WorkspaceResourceFlink", + "en": "PAI Workspace Resource Flink" + }, + "Properties": [ + { + "ROS": "GroupName", + "Terraform": null, + "Required": true + }, + { + "ROS": "IsDefault", + "Terraform": null, + "Required": false + }, + { + "ROS": "Option", + "Terraform": null, + "Required": false + }, + { + "ROS": "Resources", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "EnvType", + "Terraform": null, + "Required": true + }, + { + "ROS": "Spec", + "Terraform": null, + "Required": false + }, + { + "ROS": "WorkspaceResourceName", + "Terraform": null, + "Required": true + }, + { + "ROS": "WorkspaceResourceWorkspaceId", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "WorkspaceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::PAI::Workspace" + } + ] + } + ], + "Attributes": [ + { + "ROS": "CreateTime", + "Terraform": null + }, + { + "ROS": "GroupName", + "Terraform": null + }, + { + "ROS": "IsDefault", + "Terraform": null + }, + { + "ROS": "Resources", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::PAI::WorkspaceResourceMaxCompute", + "Terraform": null + }, + "ProductCode": "learn", + "Name": { + "zh": "PAI WorkspaceResourceMaxCompute", + "en": "PAI Workspace Resource MaxCompute" + }, + "Properties": [ + { + "ROS": "GroupName", + "Terraform": null, + "Required": true + }, + { + "ROS": "IsDefault", + "Terraform": null, + "Required": false + }, + { + "ROS": "Option", + "Terraform": null, + "Required": false + }, + { + "ROS": "Resources", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "EnvType", + "Terraform": null, + "Required": true + }, + { + "ROS": "Quotas", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "QuotaId", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "Spec", + "Terraform": null, + "Required": false + }, + { + "ROS": "WorkspaceResourceName", + "Terraform": null, + "Required": true + }, + { + "ROS": "WorkspaceResourceWorkspaceId", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "WorkspaceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::PAI::Workspace" + } + ] + } + ], + "Attributes": [ + { + "ROS": "CreateTime", + "Terraform": null + }, + { + "ROS": "GroupName", + "Terraform": null + }, + { + "ROS": "IsDefault", + "Terraform": null + }, + { + "ROS": "Resources", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::PAIDLC::Job", + "Terraform": null + }, + "ProductCode": "learn", + "Name": { + "zh": "PAIDLC Job", + "en": "PAI DLC Job" + }, + "Properties": [ + { + "ROS": "CodeSource", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Branch", + "Terraform": null, + "Required": false + }, + { + "ROS": "CodeSourceId", + "Terraform": null, + "Required": true + }, + { + "ROS": "Commit", + "Terraform": null, + "Required": false + }, + { + "ROS": "MountPath", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "DataSources", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "DataSourceId", + "Terraform": null, + "Required": true + }, + { + "ROS": "MountPath", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "DisplayName", + "Terraform": null, + "Required": true + }, + { + "ROS": "Envs", + "Terraform": null, + "Required": false + }, + { + "ROS": "JobMaxRunningTimeMinutes", + "Terraform": null, + "Required": false + }, + { + "ROS": "JobSpecs", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "EcsSpec", + "Terraform": null, + "Required": true + }, + { + "ROS": "ExtraPodSpec", + "Terraform": null, + "Required": false + }, + { + "ROS": "Image", + "Terraform": null, + "Required": true + }, + { + "ROS": "ImageConfig", + "Terraform": null, + "Required": false + }, + { + "ROS": "PodCount", + "Terraform": null, + "Required": true + }, + { + "ROS": "ResourceConfig", + "Terraform": null, + "Required": false + }, + { + "ROS": "Type", + "Terraform": null, + "Required": true + }, + { + "ROS": "UseSpotInstance", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "JobType", + "Terraform": null, + "Required": true + }, + { + "ROS": "Options", + "Terraform": null, + "Required": false + }, + { + "ROS": "Priority", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceId", + "Terraform": null, + "Required": false + }, + { + "ROS": "Settings", + "Terraform": null, + "Required": false + }, + { + "ROS": "SuccessPolicy", + "Terraform": null, + "Required": false + }, + { + "ROS": "ThirdpartyLibDir", + "Terraform": null, + "Required": false + }, + { + "ROS": "ThirdpartyLibs", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "UserCommand", + "Terraform": null, + "Required": true + }, + { + "ROS": "UserVpc", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "ExtendedCIDRs", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "SecurityGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "SwitchId", + "Terraform": null, + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ] + }, + { + "ROS": "WorkspaceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::PAI::Workspace" + } + ] + } + ], + "Attributes": [ + { + "ROS": "JobId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::PAIDLC::Tensorboard", + "Terraform": null + }, + "ProductCode": "learn", + "Name": { + "zh": "PAIDLC Tensorboard", + "en": "PAI DLC Tensorboard Instance" + }, + "Properties": [ + { + "ROS": "Cpu", + "Terraform": null, + "Required": false + }, + { + "ROS": "DataSourceId", + "Terraform": null, + "Required": true + }, + { + "ROS": "DataSources", + "Terraform": null, + "Required": false + }, + { + "ROS": "DataSourceType", + "Terraform": null, + "Required": false + }, + { + "ROS": "DisplayName", + "Terraform": null, + "Required": true + }, + { + "ROS": "JobId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::PAIDLC::Job" + } + ] + }, + { + "ROS": "MaxRunningTimeMinutes", + "Terraform": null, + "Required": false + }, + { + "ROS": "Memory", + "Terraform": null, + "Required": false + }, + { + "ROS": "Options", + "Terraform": null, + "Required": false + }, + { + "ROS": "SourceId", + "Terraform": null, + "Required": false + }, + { + "ROS": "SourceType", + "Terraform": null, + "Required": false + }, + { + "ROS": "SummaryPath", + "Terraform": null, + "Required": false + }, + { + "ROS": "SummaryRelativePath", + "Terraform": null, + "Required": false + }, + { + "ROS": "Uri", + "Terraform": null, + "Required": false + }, + { + "ROS": "WorkspaceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::PAI::Workspace" + } + ] + } + ], + "Attributes": [ + { + "ROS": "TensorboardId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "TensorboardUrl", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::PAIDatasetAcc::Endpoint", + "Terraform": null + }, + "ProductCode": "learn", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "InstanceId", + "Terraform": null, + "Required": true + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "Type", + "Terraform": null, + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VswitchId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Attributes": [ + { + "ROS": "EndpointId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::PAIPlugin::Campaign", + "Terraform": null + }, + "ProductCode": "learn", + "Name": { + "zh": "PAIPlugin Campaign", + "en": "PAI Plug-in Campaign" + }, + "Properties": [ + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "Remark", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "CampaignId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::PAIPlugin::Group", + "Terraform": null + }, + "ProductCode": "learn", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "Algorithm", + "Terraform": null, + "Required": false + }, + { + "ROS": "Column", + "Terraform": null, + "Required": false + }, + { + "ROS": "Filter", + "Terraform": null, + "Required": false + }, + { + "ROS": "InferenceJobId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::PAIPlugin::InferenceJob" + } + ] + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "PhoneNumber", + "Terraform": null, + "Required": false + }, + { + "ROS": "Project", + "Terraform": null, + "Required": false + }, + { + "ROS": "Remark", + "Terraform": null, + "Required": false + }, + { + "ROS": "Source", + "Terraform": null, + "Required": true + }, + { + "ROS": "Table", + "Terraform": null, + "Required": false + }, + { + "ROS": "Text", + "Terraform": null, + "Required": false + }, + { + "ROS": "Uri", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Amount", + "Terraform": null + }, + { + "ROS": "CreatedTime", + "Terraform": null + }, + { + "ROS": "Id", + "Terraform": null, + "Primary": true + }, + { + "ROS": "Name", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::PAIPlugin::InferenceJob", + "Terraform": null + }, + "ProductCode": "learn", + "Name": { + "zh": "PAIPlugin InferenceJob", + "en": "PAI Plug-in Inference Job" + }, + "Properties": [ + { + "ROS": "Algorithm", + "Terraform": null, + "Required": true + }, + { + "ROS": "CampaignId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::PAIPlugin::Campaign" + } + ] + }, + { + "ROS": "DataPath", + "Terraform": null, + "Required": true + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "Remark", + "Terraform": null, + "Required": false + }, + { + "ROS": "TargetPath", + "Terraform": null, + "Required": true + }, + { + "ROS": "TrainingJobId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::PAIPlugin::TrainingJob" + } + ] + }, + { + "ROS": "UserConfig", + "Terraform": null, + "Required": true + }, + { + "ROS": "WaitForInferenceFinish", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "GroupId", + "Terraform": null + }, + { + "ROS": "InferenceJobId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::PAIPlugin::Signature", + "Terraform": null + }, + "ProductCode": "learn", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "CreatedTime", + "Terraform": null + }, + { + "ROS": "Description", + "Terraform": null + }, + { + "ROS": "Id", + "Terraform": null, + "Primary": true + }, + { + "ROS": "Name", + "Terraform": null + }, + { + "ROS": "Reason", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::PAIPlugin::Template", + "Terraform": null + }, + "ProductCode": "learn", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "Content", + "Terraform": null, + "Required": true + }, + { + "ROS": "Description", + "Terraform": null, + "Required": true + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "Signature", + "Terraform": null, + "Required": false + }, + { + "ROS": "SignatureId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ApiGateway::Signature" + } + ] + }, + { + "ROS": "Type", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "CreatedTime", + "Terraform": null + }, + { + "ROS": "Description", + "Terraform": null + }, + { + "ROS": "Id", + "Terraform": null, + "Primary": true + }, + { + "ROS": "Name", + "Terraform": null + }, + { + "ROS": "Reason", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::PAIPlugin::TrainingJob", + "Terraform": null + }, + "ProductCode": "learn", + "Name": { + "zh": "PAIPlugin TrainingJob", + "en": "PAI Plug-in Training Job" + }, + "Properties": [ + { + "ROS": "Algorithm", + "Terraform": null, + "Required": true + }, + { + "ROS": "CampaignId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::PAIPlugin::Campaign" + } + ] + }, + { + "ROS": "DataPath", + "Terraform": null, + "Required": true + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "Remark", + "Terraform": null, + "Required": false + }, + { + "ROS": "UserConfig", + "Terraform": null, + "Required": true + }, + { + "ROS": "WaitForTrainingFinish", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "TrainingJobId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::POLARDB::AITask", + "Terraform": null + }, + "ProductCode": "polardb", + "Name": { + "zh": "PolarDB for AI", + "en": "PolarDB for AI" + }, + "Properties": [ + { + "ROS": "DBClusterId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::POLARDB::DBCluster" + } + ] + }, + { + "ROS": "NodeType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Password", + "Terraform": null, + "Required": true + }, + { + "ROS": "Username", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "DBClusterId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::POLARDB::Account", + "Terraform": "alicloud_polardb_account" + }, + "ProductCode": "polardb", + "Name": { + "zh": "PolarDB数据库账号", + "en": "PolarDB Account" + }, + "Properties": [ + { + "ROS": "AccountDescription", + "Terraform": "account_description", + "Required": false + }, + { + "ROS": "AccountName", + "Terraform": "account_name", + "Required": true + }, + { + "ROS": "AccountPassword", + "Terraform": "account_password", + "Required": true + }, + { + "ROS": "AccountPrivilege", + "Terraform": null, + "Required": false + }, + { + "ROS": "AccountType", + "Terraform": "account_type", + "Required": false + }, + { + "ROS": "DBClusterId", + "Terraform": "db_cluster_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::POLARDB::DBCluster" + } + ] + }, + { + "ROS": "DBName", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "kms_encrypted_password", + "Required": false + }, + { + "ROS": null, + "Terraform": "kms_encryption_context", + "Required": false + }, + { + "ROS": "PrivForAllDB", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::POLARDB::AccountPrivilege", + "Terraform": "alicloud_polardb_account_privilege" + }, + "ProductCode": "polardb", + "Name": { + "zh": "授权PolarDB账号", + "en": "PolarDB Account Authorization" + }, + "Properties": [ + { + "ROS": "AccountName", + "Terraform": "account_name", + "Required": true + }, + { + "ROS": "AccountPrivilege", + "Terraform": "account_privilege", + "Required": true + }, + { + "ROS": "DBClusterId", + "Terraform": "db_cluster_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::POLARDB::DBCluster" + } + ] + }, + { + "ROS": "DBName", + "Terraform": "db_names", + "Required": true + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::POLARDB::Backup", + "Terraform": null + }, + "ProductCode": "polardb", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "DBClusterId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::POLARDB::DBCluster" + } + ] + } + ], + "Attributes": [ + { + "ROS": "BackupJobId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "DBClusterId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::POLARDB::DBCluster", + "Terraform": "alicloud_polardb_cluster" + }, + "ProductCode": "polardb", + "Name": { + "zh": "PolarDB集群", + "en": "PolarDB Cluster" + }, + "Properties": [ + { + "ROS": "AllowShutDown", + "Terraform": "allow_shut_down", + "Required": false + }, + { + "ROS": "Architecture", + "Terraform": null, + "Required": false + }, + { + "ROS": "AutoRenewPeriod", + "Terraform": "auto_renew_period", + "Required": false + }, + { + "ROS": "BackupRetentionPolicyOnClusterDeletion", + "Terraform": "backup_retention_policy_on_cluster_deletion", + "Required": false + }, + { + "ROS": "CloneDataPoint", + "Terraform": "clone_data_point", + "Required": false + }, + { + "ROS": "ClusterNetworkType", + "Terraform": null, + "Required": false + }, + { + "ROS": "ColdStorageOption", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "Enable", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": null, + "Terraform": "collector_status", + "Required": false + }, + { + "ROS": null, + "Terraform": "compress_storage", + "Required": false + }, + { + "ROS": "CreationCategory", + "Terraform": "creation_category", + "Required": false + }, + { + "ROS": "CreationOption", + "Terraform": "creation_option", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_cluster_ip_array", + "Required": false + }, + { + "ROS": "DBClusterParameters", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "EffectiveTime", + "Terraform": null, + "Required": false + }, + { + "ROS": "Parameters", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "DBMinorVersion", + "Terraform": null, + "Required": false + }, + { + "ROS": "DBNodeClass", + "Terraform": "db_node_class", + "Required": true + }, + { + "ROS": null, + "Terraform": "db_node_count", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_node_id", + "Required": false + }, + { + "ROS": "DBNodeNum", + "Terraform": "db_node_num", + "Required": false + }, + { + "ROS": "DBType", + "Terraform": "db_type", + "Required": true + }, + { + "ROS": "DBVersion", + "Terraform": "db_version", + "Required": true + }, + { + "ROS": "DefaultTimeZone", + "Terraform": "default_time_zone", + "Required": false + }, + { + "ROS": null, + "Terraform": "deletion_lock", + "Required": false + }, + { + "ROS": "DeletionProtection", + "Terraform": null, + "Required": false + }, + { + "ROS": "DBClusterDescription", + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "encryption_key", + "Required": false + }, + { + "ROS": null, + "Terraform": "encrypt_new_tables", + "Required": false + }, + { + "ROS": null, + "Terraform": "from_time_service", + "Required": false + }, + { + "ROS": "GDNId", + "Terraform": "gdn_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "hot_replica_mode", + "Required": false + }, + { + "ROS": "HotStandbyCluster", + "Terraform": "hot_standby_cluster", + "Required": false + }, + { + "ROS": null, + "Terraform": "imci_switch", + "Required": false + }, + { + "ROS": "LoosePolarLogBin", + "Terraform": "loose_polar_log_bin", + "Required": false + }, + { + "ROS": "LooseXEngine", + "Terraform": "loose_xengine", + "Required": false + }, + { + "ROS": "LooseXEngineUseMemoryPct", + "Terraform": "loose_xengine_use_memory_pct", + "Required": false + }, + { + "ROS": "LowerCaseTableNames", + "Terraform": "lower_case_table_names", + "Required": false + }, + { + "ROS": "MaintainTime", + "Terraform": "maintain_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "modify_type", + "Required": false + }, + { + "ROS": "ParameterGroupId", + "Terraform": "parameter_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::POLARDB::ParameterGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "parameters", + "Required": false + }, + { + "ROS": "PayType", + "Terraform": "pay_type", + "Required": true + }, + { + "ROS": "Period", + "Terraform": "period", + "Required": false + }, + { + "ROS": "PeriodUnit", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "planned_end_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "planned_start_time", + "Required": false + }, + { + "ROS": "ProvisionedIops", + "Terraform": "provisioned_iops", + "Required": false + }, + { + "ROS": "ProxyClass", + "Terraform": "proxy_class", + "Required": false + }, + { + "ROS": "ProxyType", + "Terraform": "proxy_type", + "Required": false + }, + { + "ROS": "RenewalStatus", + "Terraform": "renewal_status", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "RestartMasterNode", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "role_arn", + "Required": false + }, + { + "ROS": null, + "Terraform": "scale_ap_ro_num_max", + "Required": false + }, + { + "ROS": null, + "Terraform": "scale_ap_ro_num_min", + "Required": false + }, + { + "ROS": "ScaleMax", + "Terraform": "scale_max", + "Required": false + }, + { + "ROS": "ScaleMin", + "Terraform": "scale_min", + "Required": false + }, + { + "ROS": "ScaleRoNumMax", + "Terraform": "scale_ro_num_max", + "Required": false + }, + { + "ROS": "ScaleRoNumMin", + "Terraform": "scale_ro_num_min", + "Required": false + }, + { + "ROS": null, + "Terraform": "seconds_until_auto_pause", + "Required": false + }, + { + "ROS": "SecurityGroupIds", + "Terraform": "security_group_ids", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "SecurityIPList", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "serverless_steady_switch", + "Required": false + }, + { + "ROS": "ServerlessType", + "Terraform": "serverless_type", + "Required": false + }, + { + "ROS": "SourceResourceId", + "Terraform": "source_resource_id", + "Required": false + }, + { + "ROS": "SSLEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "StandbyAZ", + "Terraform": null, + "Required": false + }, + { + "ROS": "StorageAutoScale", + "Terraform": null, + "Required": false + }, + { + "ROS": "StoragePayType", + "Terraform": "storage_pay_type", + "Required": false + }, + { + "ROS": "StorageSpace", + "Terraform": "storage_space", + "Required": false + }, + { + "ROS": "StorageType", + "Terraform": "storage_type", + "Required": false + }, + { + "ROS": "StorageUpperBound", + "Terraform": null, + "Required": false + }, + { + "ROS": "StrictConsistency", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "sub_category", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": null, + "Terraform": "target_db_revision_version_code", + "Required": false + }, + { + "ROS": "TDEStatus", + "Terraform": "tde_status", + "Required": false + }, + { + "ROS": null, + "Terraform": "upgrade_type", + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "ZoneId", + "Terraform": "zone_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": "ClusterConnectionString", + "Terraform": null + }, + { + "ROS": "ClusterEndpointId", + "Terraform": null + }, + { + "ROS": "ColdStorageInstanceId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "connection_string" + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "CustomConnectionStrings", + "Terraform": null + }, + { + "ROS": "CustomEndpointIds", + "Terraform": null + }, + { + "ROS": "DBClusterDescription", + "Terraform": null + }, + { + "ROS": "DBNodeIds", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "db_revision_version_list" + }, + { + "ROS": "DBClusterId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "OrderId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "port" + }, + { + "ROS": "PrimaryConnectionString", + "Terraform": null + }, + { + "ROS": "PrimaryConnectionStrings", + "Terraform": null + }, + { + "ROS": "PrimaryEndpointId", + "Terraform": null + }, + { + "ROS": "PrimaryEndpointIds", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": null, + "Terraform": "tde_region" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::POLARDB::DBClusterAccessWhiteList", + "Terraform": null + }, + "ProductCode": "polardb", + "Name": { + "zh": "PolarDB集群访问IP白名单", + "en": "PolarDB Cluster IP Whitelist" + }, + "Properties": [ + { + "ROS": "DBClusterId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::POLARDB::DBCluster" + } + ] + }, + { + "ROS": "DBClusterIPArrayName", + "Terraform": null, + "Required": false + }, + { + "ROS": "SecurityIps", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "DBClusterId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::POLARDB::DBClusterEndpoint", + "Terraform": "alicloud_polardb_endpoint" + }, + "ProductCode": "polardb", + "Name": { + "zh": "PolarDB自定义集群地址", + "en": "Custom PolarDB Cluster Endpoint" + }, + "Properties": [ + { + "ROS": "AutoAddNewNodes", + "Terraform": "auto_add_new_nodes", + "Required": false + }, + { + "ROS": null, + "Terraform": "connection_prefix", + "Required": false + }, + { + "ROS": "DBClusterId", + "Terraform": "db_cluster_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::POLARDB::DBCluster" + } + ] + }, + { + "ROS": null, + "Terraform": "db_endpoint_description", + "Required": false + }, + { + "ROS": "EndpointConfig", + "Terraform": "endpoint_config", + "Required": false + }, + { + "ROS": "EndpointType", + "Terraform": "endpoint_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "net_type", + "Required": false + }, + { + "ROS": "Nodes", + "Terraform": "nodes", + "Required": false + }, + { + "ROS": null, + "Terraform": "port", + "Required": false + }, + { + "ROS": "ReadWriteMode", + "Terraform": "read_write_mode", + "Required": false + }, + { + "ROS": null, + "Terraform": "ssl_auto_rotate", + "Required": false + }, + { + "ROS": null, + "Terraform": "ssl_certificate_url", + "Required": false + }, + { + "ROS": null, + "Terraform": "ssl_enabled", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Addresses", + "Terraform": null + }, + { + "ROS": "ConnectionString", + "Terraform": null + }, + { + "ROS": "DBEndpointId", + "Terraform": "db_endpoint_id" + }, + { + "ROS": "DBEndpointId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "ssl_connection_string" + }, + { + "ROS": null, + "Terraform": "ssl_expire_time" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::POLARDB::DBClusterEndpointAddress", + "Terraform": "alicloud_polardb_endpoint_address" + }, + "ProductCode": "polardb", + "Name": { + "zh": "PolarDB集群公网地址", + "en": "Public PolarDB Cluster Endpoint" + }, + "Properties": [ + { + "ROS": "ConnectionStringPrefix", + "Terraform": "connection_prefix", + "Required": false + }, + { + "ROS": "DBClusterId", + "Terraform": "db_cluster_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::POLARDB::DBCluster" + } + ] + }, + { + "ROS": "DBEndpointId", + "Terraform": "db_endpoint_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::POLARDB::DBClusterEndpoint" + } + ] + }, + { + "ROS": "NetType", + "Terraform": "net_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "port", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Address", + "Terraform": null + }, + { + "ROS": "ConnectionString", + "Terraform": "connection_string" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "ip_address" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::POLARDB::DBNodes", + "Terraform": null + }, + "ProductCode": "polardb", + "Name": { + "zh": "PolarDB集群节点", + "en": "PolarDB Cluster Nodes" + }, + "Properties": [ + { + "ROS": "Amount", + "Terraform": null, + "Required": true + }, + { + "ROS": "DBClusterId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::POLARDB::DBCluster" + } + ] + }, + { + "ROS": "DBNodeType", + "Terraform": null, + "Required": false + }, + { + "ROS": "EndpointBindList", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "ImciSwitch", + "Terraform": null, + "Required": false + }, + { + "ROS": "PlannedEndTime", + "Terraform": null, + "Required": false + }, + { + "ROS": "PlannedStartTime", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + } + ], + "Attributes": [ + { + "ROS": "DBNodeIds", + "Terraform": null, + "Primary": true + }, + { + "ROS": "OrderIds", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::POLARDB::Database", + "Terraform": "alicloud_polardb_database" + }, + "ProductCode": "polardb", + "Name": { + "zh": "PolarDB数据库", + "en": "PolarDB Database" + }, + "Properties": [ + { + "ROS": "AccountName", + "Terraform": "account_name", + "Required": false + }, + { + "ROS": "AccountPrivilege", + "Terraform": null, + "Required": false + }, + { + "ROS": "CharacterSetName", + "Terraform": "character_set_name", + "Required": true + }, + { + "ROS": "Collate", + "Terraform": null, + "Required": false + }, + { + "ROS": "Ctype", + "Terraform": null, + "Required": false + }, + { + "ROS": "DBClusterId", + "Terraform": "db_cluster_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::POLARDB::DBCluster" + } + ] + }, + { + "ROS": "DBDescription", + "Terraform": "db_description", + "Required": false + }, + { + "ROS": "DBName", + "Terraform": "db_name", + "Required": true + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::POLARDB::GlobalDatabaseNetwork", + "Terraform": "alicloud_polardb_global_database_network" + }, + "ProductCode": "polardb", + "Name": { + "zh": "PolarDB全球数据库网络", + "en": "PolarDB GDN" + }, + "Properties": [ + { + "ROS": "DbClusterId", + "Terraform": "db_cluster_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::POLARDB::DBCluster" + } + ] + }, + { + "ROS": "GdnDescription", + "Terraform": "description", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Connections", + "Terraform": null + }, + { + "ROS": "CreateTime", + "Terraform": null + }, + { + "ROS": "DbClusters", + "Terraform": null + }, + { + "ROS": "DbType", + "Terraform": null + }, + { + "ROS": "DbVersion", + "Terraform": null + }, + { + "ROS": "GdnDescription", + "Terraform": null + }, + { + "ROS": "GdnId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::POLARDB::GlobalSecurityIPGroup", + "Terraform": null + }, + "ProductCode": "polardb", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "GIpList", + "Terraform": null, + "Required": true, + "Type": "list", + "Properties": {} + }, + { + "ROS": "GlobalIgName", + "Terraform": null, + "Required": true + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "GlobalSecurityGroupId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::POLARDB::ParameterGroup", + "Terraform": "alicloud_polardb_parameter_group" + }, + "ProductCode": "polardb", + "Name": { + "zh": "PolarDB参数模板列表", + "en": "PolarDB Parameter Template" + }, + "Properties": [ + { + "ROS": "DbType", + "Terraform": "db_type", + "Required": true + }, + { + "ROS": "DbVersion", + "Terraform": "db_version", + "Required": true + }, + { + "ROS": "ParameterGroupDesc", + "Terraform": "description", + "Required": false + }, + { + "ROS": "ParameterGroupName", + "Terraform": "name", + "Required": true + }, + { + "ROS": "Parameters", + "Terraform": "parameters", + "Required": true, + "Properties": [ + { + "ROS": "ParamName", + "Terraform": "param_name", + "Required": true + }, + { + "ROS": "ParamValue", + "Terraform": "param_value", + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": null, + "Terraform": "param_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "param_value", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + } + ], + "Attributes": [ + { + "ROS": "CreateTime", + "Terraform": null + }, + { + "ROS": "DbType", + "Terraform": null + }, + { + "ROS": "DbVersion", + "Terraform": null + }, + { + "ROS": "ForceRestart", + "Terraform": null + }, + { + "ROS": "ParameterGroupId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "ParameterCounts", + "Terraform": null + }, + { + "ROS": "ParameterGroupDesc", + "Terraform": null + }, + { + "ROS": "ParameterGroupName", + "Terraform": null + }, + { + "ROS": "ParameterGroupType", + "Terraform": null + }, + { + "ROS": "Parameters", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::PVTZ::Rule", + "Terraform": "alicloud_pvtz_rule" + }, + "ProductCode": "pvtz", + "Name": { + "zh": "PrivateZone转发规则", + "en": "Alibaba Cloud DNS PrivateZone Forwarding Rule" + }, + "Properties": [ + { + "ROS": "EndpointId", + "Terraform": "endpoint_id", + "Required": true + }, + { + "ROS": "ForwardIp", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "Ip", + "Terraform": null, + "Required": true + }, + { + "ROS": "Port", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": null, + "Terraform": "forward_ips", + "Required": false + }, + { + "ROS": "RuleName", + "Terraform": "rule_name", + "Required": true + }, + { + "ROS": "Type", + "Terraform": "type", + "Required": true + }, + { + "ROS": "ZoneName", + "Terraform": "zone_name", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "CreateTime", + "Terraform": null + }, + { + "ROS": "EndpointId", + "Terraform": null + }, + { + "ROS": "EndpointName", + "Terraform": null + }, + { + "ROS": "ForwardIp", + "Terraform": null + }, + { + "ROS": "RuleName", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "RuleName", + "Terraform": null + }, + { + "ROS": "Type", + "Terraform": null + }, + { + "ROS": "Vpcs", + "Terraform": null + }, + { + "ROS": "ZoneName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::PVTZ::SyncEcsHost", + "Terraform": null + }, + "ProductCode": "pvtz", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "Regions", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "RegionId", + "Terraform": null, + "Required": true + }, + { + "ROS": "UserId", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "Status", + "Terraform": null, + "Required": true + }, + { + "ROS": "ZoneId", + "Terraform": null, + "Required": true + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::PVTZ::UserVpcAuthorization", + "Terraform": "alicloud_pvtz_user_vpc_authorization" + }, + "ProductCode": "pvtz", + "Name": { + "zh": "PrivateZone跨账号VPC授权", + "en": "Cross-account VPC Authorization in Alibaba Cloud DNS PrivateZone" + }, + "Properties": [ + { + "ROS": "AuthChannel", + "Terraform": "auth_channel", + "Required": false + }, + { + "ROS": "AuthCode", + "Terraform": null, + "Required": false + }, + { + "ROS": "AuthorizedUserId", + "Terraform": "authorized_user_id", + "Required": true + }, + { + "ROS": "AuthType", + "Terraform": "auth_type", + "Required": false + }, + { + "ROS": "IgnoreDeletionForbidden", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "AuthorizedUserId", + "Terraform": null + }, + { + "ROS": "AuthType", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::PVTZ::Zone", + "Terraform": "alicloud_pvtz_zone" + }, + "ProductCode": "pvtz", + "Name": { + "zh": "PrivateZone", + "en": "Private Zone" + }, + "Properties": [ + { + "ROS": "DnsGroup", + "Terraform": null, + "Required": false + }, + { + "ROS": "IgnoredStackTagKeys", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": null, + "Terraform": "lang", + "Required": false + }, + { + "ROS": "ProxyPattern", + "Terraform": "proxy_pattern", + "Required": false + }, + { + "ROS": "Remark", + "Terraform": "remark", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "sync_status", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": null, + "Terraform": "user_client_ip", + "Required": false + }, + { + "ROS": null, + "Terraform": "user_info", + "Required": false + }, + { + "ROS": "ZoneName", + "Terraform": "zone_name", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "creation_time" + }, + { + "ROS": "ZoneId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "is_ptr" + }, + { + "ROS": null, + "Terraform": "record_count" + }, + { + "ROS": null, + "Terraform": "update_time" + }, + { + "ROS": "ZoneName", + "Terraform": null + }, + { + "ROS": "ZoneTag", + "Terraform": null + }, + { + "ROS": "ZoneType", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::PVTZ::ZoneRecord", + "Terraform": "alicloud_pvtz_zone_record" + }, + "ProductCode": "pvtz", + "Name": { + "zh": "PrivateZone解析记录", + "en": "Private Zone DNS Record" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "lang", + "Required": false + }, + { + "ROS": "Priority", + "Terraform": "priority", + "Required": false + }, + { + "ROS": null, + "Terraform": "remark", + "Required": false + }, + { + "ROS": "Rr", + "Terraform": "rr", + "Required": true + }, + { + "ROS": "Status", + "Terraform": "status", + "Required": true + }, + { + "ROS": "Ttl", + "Terraform": "ttl", + "Required": false + }, + { + "ROS": "Type", + "Terraform": "type", + "Required": true + }, + { + "ROS": "Value", + "Terraform": "value", + "Required": true + }, + { + "ROS": "ZoneId", + "Terraform": "zone_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::PVTZ::Zone" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "Record", + "Terraform": null + }, + { + "ROS": "RecordId", + "Terraform": "record_id" + }, + { + "ROS": "ZoneId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::PVTZ::ZoneVpcBinder", + "Terraform": null + }, + "ProductCode": "pvtz", + "Name": { + "zh": "PrivateZone VPC绑定", + "en": "Bind Private Zone to VPCs" + }, + "Properties": [ + { + "ROS": "Vpcs", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ], + "Properties": [ + { + "ROS": "RegionId", + "Terraform": null, + "Required": true + }, + { + "ROS": "VpcId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ], + "Type": "list" + }, + { + "ROS": "ZoneId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ALIYUN::PVTZ::Zone" + } + ] + } + ], + "Attributes": [ + { + "ROS": "Vpcs", + "Terraform": null + }, + { + "ROS": "ZoneId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::PaiDswApi::Instance", + "Terraform": null + }, + "ProductCode": "learn", + "Name": { + "zh": "PaiDswApi实例", + "en": "PAI DSW Instance" + }, + "Properties": [ + { + "ROS": "Accessibility", + "Terraform": null, + "Required": false + }, + { + "ROS": "Datasets", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "DatasetId", + "Terraform": null, + "Required": false + }, + { + "ROS": "MountPath", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "EcsSpec", + "Terraform": null, + "Required": true + }, + { + "ROS": "EnvironmentVariables", + "Terraform": null, + "Required": false + }, + { + "ROS": "ImageUrl", + "Terraform": null, + "Required": true + }, + { + "ROS": "InstanceName", + "Terraform": null, + "Required": true + }, + { + "ROS": "Labels", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": false + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "SaveImage", + "Terraform": null, + "Required": false + }, + { + "ROS": "UserVpc", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "SecurityGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "VpcId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ] + }, + { + "ROS": "WorkspaceId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::PAI::Workspace" + } + ] + } + ], + "Attributes": [ + { + "ROS": "Accessibility", + "Terraform": null + }, + { + "ROS": "Datasets", + "Terraform": null + }, + { + "ROS": "EcsSpec", + "Terraform": null + }, + { + "ROS": "EnvironmentVariables", + "Terraform": null + }, + { + "ROS": "ImageUrl", + "Terraform": null + }, + { + "ROS": "InstanceId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "InstanceName", + "Terraform": null + }, + { + "ROS": "InstanceUrl", + "Terraform": null + }, + { + "ROS": "JupyterlabUrl", + "Terraform": null + }, + { + "ROS": "Labels", + "Terraform": null + }, + { + "ROS": "PaymentType", + "Terraform": null + }, + { + "ROS": "TerminalUrl", + "Terraform": null + }, + { + "ROS": "UserVpc", + "Terraform": null + }, + { + "ROS": "WebIDEUrl", + "Terraform": null + }, + { + "ROS": "WorkspaceId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::PolarDBX::Account", + "Terraform": null + }, + "ProductCode": "polardb", + "Name": { + "zh": "PolarDB-X 2.0数据库账号", + "en": "PolarDB-X Database Account" + }, + "Properties": [ + { + "ROS": "AccountDescription", + "Terraform": null, + "Required": false + }, + { + "ROS": "AccountName", + "Terraform": null, + "Required": true + }, + { + "ROS": "AccountPassword", + "Terraform": null, + "Required": true + }, + { + "ROS": "DBInstanceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::PolarDBX::DBInstance" + } + ] + } + ], + "Attributes": [ + { + "ROS": "AccountDescription", + "Terraform": null + }, + { + "ROS": "AccountName", + "Terraform": null + }, + { + "ROS": "AccountType", + "Terraform": null + }, + { + "ROS": "DBInstanceId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::PolarDBX::DBInstance", + "Terraform": "alicloud_drds_polardbx_instance" + }, + "ProductCode": "polardb", + "Name": { + "zh": "PolarDB-X 2.0实例", + "en": "PolarDB-X Instance" + }, + "Properties": [ + { + "ROS": "AutoRenew", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "cn_class", + "Required": false + }, + { + "ROS": null, + "Terraform": "cn_node_count", + "Required": false + }, + { + "ROS": "DBInstanceDescription", + "Terraform": null, + "Required": false + }, + { + "ROS": "DBNodeClass", + "Terraform": null, + "Required": true + }, + { + "ROS": "DBNodeCount", + "Terraform": null, + "Required": true + }, + { + "ROS": null, + "Terraform": "dn_class", + "Required": false + }, + { + "ROS": null, + "Terraform": "dn_node_count", + "Required": false + }, + { + "ROS": "EngineVersion", + "Terraform": null, + "Required": true + }, + { + "ROS": "PayType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Period", + "Terraform": null, + "Required": false + }, + { + "ROS": "PrimaryZone", + "Terraform": "primary_zone", + "Required": true + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "SecondaryZone", + "Terraform": "secondary_zone", + "Required": false + }, + { + "ROS": "SecurityIpConfig", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "GroupName", + "Terraform": null, + "Required": false + }, + { + "ROS": "ModifyMode", + "Terraform": null, + "Required": false + }, + { + "ROS": "SecurityIPList", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "TertiaryZone", + "Terraform": "tertiary_zone", + "Required": false + }, + { + "ROS": "TopologyType", + "Terraform": "topology_type", + "Required": true + }, + { + "ROS": "UsedTime", + "Terraform": null, + "Required": false + }, + { + "ROS": "VPCId", + "Terraform": "vpc_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Attributes": [ + { + "ROS": "ConnectionString", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "DBInstanceName", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "OrderId", + "Terraform": null + }, + { + "ROS": "Port", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::PolarDBX::Database", + "Terraform": null + }, + "ProductCode": "polardb", + "Name": { + "zh": "PolarDB-X 2.0数据库", + "en": "PolarDB-X Database" + }, + "Properties": [ + { + "ROS": "Accounts", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "AccountName", + "Terraform": null, + "Required": true + }, + { + "ROS": "AccountPrivilege", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "CharacterSetName", + "Terraform": null, + "Required": true + }, + { + "ROS": "DatabaseDescription", + "Terraform": null, + "Required": false + }, + { + "ROS": "DatabaseName", + "Terraform": null, + "Required": true + }, + { + "ROS": "DBInstanceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::PolarDBX::DBInstance" + } + ] + }, + { + "ROS": "Mode", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Accounts", + "Terraform": null + }, + { + "ROS": "CharacterSetName", + "Terraform": null + }, + { + "ROS": "DatabaseDescription", + "Terraform": null + }, + { + "ROS": "DatabaseName", + "Terraform": null, + "Primary": true + }, + { + "ROS": "DBInstanceId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::PrivateLink::VpcEndpoint", + "Terraform": "alicloud_privatelink_vpc_endpoint" + }, + "ProductCode": "privatelink", + "Name": { + "zh": "终端节点", + "en": "Endpoint" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": "EndpointDescription", + "Terraform": "endpoint_description", + "Required": false + }, + { + "ROS": "EndpointType", + "Terraform": "endpoint_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "policy_document", + "Required": false + }, + { + "ROS": "ProtectedEnabled", + "Terraform": "protected_enabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "SecurityGroupId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ], + "Properties": {}, + "Type": "list" + }, + { + "ROS": null, + "Terraform": "security_group_ids", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "ServiceId", + "Terraform": "service_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::PrivateLink::VpcEndpointService" + } + ] + }, + { + "ROS": "ServiceName", + "Terraform": "service_name", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "EndpointName", + "Terraform": "vpc_endpoint_name", + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "Zone", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Ip", + "Terraform": null, + "Required": false + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "ZoneId", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "ZonePrivateIpAddressCount", + "Terraform": "zone_private_ip_address_count", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": "Bandwidth", + "Terraform": "bandwidth" + }, + { + "ROS": null, + "Terraform": "connection_status" + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "endpoint_business_status" + }, + { + "ROS": "EndpointDomain", + "Terraform": "endpoint_domain" + }, + { + "ROS": "EndpointName", + "Terraform": null + }, + { + "ROS": "EndpointId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "ServiceId", + "Terraform": null + }, + { + "ROS": "ServiceName", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "VpcId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "ZoneDomains", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::PrivateLink::VpcEndpointService", + "Terraform": "alicloud_privatelink_vpc_endpoint_service" + }, + "ProductCode": "privatelink", + "Name": { + "zh": "终端节点服务", + "en": "Endpoint Service" + }, + "Properties": [ + { + "ROS": "AutoAcceptEnabled", + "Terraform": "auto_accept_connection", + "Required": false + }, + { + "ROS": "ConnectBandwidth", + "Terraform": "connect_bandwidth", + "Required": false + }, + { + "ROS": "DeletionForce", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": "Payer", + "Terraform": "payer", + "Required": false + }, + { + "ROS": "Resource", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "ResourceId", + "Terraform": null, + "Required": true + }, + { + "ROS": "ResourceType", + "Terraform": null, + "Required": true + }, + { + "ROS": "ZoneId", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "ServiceDescription", + "Terraform": "service_description", + "Required": false + }, + { + "ROS": "ServiceResourceType", + "Terraform": "service_resource_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "service_support_ipv6", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "User", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "ZoneAffinityEnabled", + "Terraform": "zone_affinity_enabled", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "ServiceId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "MaxBandwidth", + "Terraform": null + }, + { + "ROS": "MinBandwidth", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "service_business_status" + }, + { + "ROS": "ServiceDescription", + "Terraform": null + }, + { + "ROS": "ServiceDomain", + "Terraform": "service_domain" + }, + { + "ROS": "ServiceName", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": null, + "Terraform": "vpc_endpoint_service_name" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::PrivateLink::VpcEndpointServiceAttachment", + "Terraform": null + }, + "MainResourceType": { + "ResourceType": "ROS/ALIYUN::PrivateLink::VpcEndpointService", + "RefProperty": "ROS/ServiceId" + }, + "ProductCode": "privatelink", + "Name": { + "zh": "添加服务资源", + "en": "Attach Service Resource" + }, + "Properties": [ + { + "ROS": "ResourceId", + "Terraform": null, + "Required": true + }, + { + "ROS": "ResourceType", + "Terraform": null, + "Required": true + }, + { + "ROS": "ServiceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::PrivateLink::VpcEndpointService" + } + ] + } + ], + "Attributes": [ + { + "ROS": "ResourceId", + "Terraform": null + }, + { + "ROS": "ResourceType", + "Terraform": null + }, + { + "ROS": "ServiceId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::REDIS::Account", + "Terraform": null + }, + "ProductCode": "kvstore", + "Name": { + "zh": "Redis账号", + "en": "Tair (Redis OSS-compatible) Account" + }, + "Properties": [ + { + "ROS": "AccountDescription", + "Terraform": null, + "Required": false + }, + { + "ROS": "AccountName", + "Terraform": null, + "Required": true + }, + { + "ROS": "AccountPassword", + "Terraform": null, + "Required": true + }, + { + "ROS": "AccountPrivilege", + "Terraform": null, + "Required": false + }, + { + "ROS": "AccountType", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::REDIS::Instance" + } + ] + } + ], + "Attributes": [ + { + "ROS": "AccountName", + "Terraform": null, + "Primary": true + }, + { + "ROS": "InstanceId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::REDIS::AuditLogConfig", + "Terraform": null + }, + "ProductCode": "kvstore", + "Name": { + "zh": "REDIS AuditLogConfig", + "en": "Tair (Redis OSS-compatible) Audit Log Settings" + }, + "Properties": [ + { + "ROS": "InstanceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::REDIS::Instance" + } + ] + }, + { + "ROS": "Retention", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "InstanceId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::REDIS::Connection", + "Terraform": null + }, + "ProductCode": "kvstore", + "Name": { + "zh": "Redis公网连接地址", + "en": "Tair (Redis OSS-compatible) Public Endpoint" + }, + "Properties": [ + { + "ROS": "ConnectionStringPrefix", + "Terraform": null, + "Required": true + }, + { + "ROS": "ConnectionType", + "Terraform": null, + "Required": true + }, + { + "ROS": "InstanceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::REDIS::Instance" + } + ] + }, + { + "ROS": "Port", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "ConnectionString", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::REDIS::Instance", + "Terraform": null + }, + "ProductCode": "kvstore", + "Name": { + "zh": "Redis实例", + "en": "Tair (Redis OSS-compatible) Instance" + }, + "Properties": [ + { + "ROS": "AutoRenewDuration", + "Terraform": null, + "Required": false + }, + { + "ROS": "BackupPolicy", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "EnableBackupLog", + "Terraform": null, + "Required": false + }, + { + "ROS": "PreferredBackupPeriod", + "Terraform": null, + "Required": true + }, + { + "ROS": "PreferredBackupTime", + "Terraform": null, + "Required": true + } + ] + }, + { + "ROS": "ChargeType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Connections", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "ClassicInnerConnection", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "ConnectionPort", + "Terraform": null, + "Required": true + }, + { + "ROS": "ConnectionString", + "Terraform": null, + "Required": true + } + ] + }, + { + "ROS": "DirectConnection", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "ConnectionPort", + "Terraform": null, + "Required": true + }, + { + "ROS": "ConnectionString", + "Terraform": null, + "Required": true + } + ] + }, + { + "ROS": "PublicConnection", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "ConnectionPort", + "Terraform": null, + "Required": true + }, + { + "ROS": "ConnectionString", + "Terraform": null, + "Required": true + } + ] + }, + { + "ROS": "VpcPrivateConnection", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "ConnectionPort", + "Terraform": null, + "Required": true + }, + { + "ROS": "ConnectionString", + "Terraform": null, + "Required": true + } + ] + } + ] + }, + { + "ROS": "DeletionForce", + "Terraform": null, + "Required": false + }, + { + "ROS": "DeletionProtection", + "Terraform": null, + "Required": false + }, + { + "ROS": "EngineVersion", + "Terraform": null, + "Required": false + }, + { + "ROS": "EvictionPolicy", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceClass", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceMaintainTime", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "MaintainEndTime", + "Terraform": null, + "Required": false + }, + { + "ROS": "MaintainStartTime", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "InstanceName", + "Terraform": null, + "Required": false + }, + { + "ROS": "NodeType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Password", + "Terraform": null, + "Required": false + }, + { + "ROS": "Period", + "Terraform": null, + "Required": false + }, + { + "ROS": "PeriodUnit", + "Terraform": null, + "Required": false + }, + { + "ROS": "ProductType", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "SecondaryZoneId", + "Terraform": null, + "Required": false + }, + { + "ROS": "SecurityGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "ShardCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "SSLEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "TairConfig", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "ShardCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "Storage", + "Terraform": null, + "Required": false + }, + { + "ROS": "StorageType", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "VpcId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VpcPasswordFree", + "Terraform": null, + "Required": false + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "ZoneId", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "ArchitectureType", + "Terraform": null + }, + { + "ROS": "Bandwidth", + "Terraform": null + }, + { + "ROS": "Capacity", + "Terraform": null + }, + { + "ROS": "ChargeType", + "Terraform": null + }, + { + "ROS": "ClassicInnerConnectionPort", + "Terraform": null + }, + { + "ROS": "ClassicInnerConnectionString", + "Terraform": null + }, + { + "ROS": "ConnectionDomain", + "Terraform": null + }, + { + "ROS": "Connections", + "Terraform": null + }, + { + "ROS": "DirectConnectionPort", + "Terraform": null + }, + { + "ROS": "DirectConnectionString", + "Terraform": null + }, + { + "ROS": "EngineVersion", + "Terraform": null + }, + { + "ROS": "HasRenewChangeOrder", + "Terraform": null + }, + { + "ROS": "InstanceClass", + "Terraform": null + }, + { + "ROS": "InstanceId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "InstanceName", + "Terraform": null + }, + { + "ROS": "InstanceType", + "Terraform": null + }, + { + "ROS": "NetworkType", + "Terraform": null + }, + { + "ROS": "NodeType", + "Terraform": null + }, + { + "ROS": "OrderId", + "Terraform": null + }, + { + "ROS": "PackageType", + "Terraform": null + }, + { + "ROS": "Port", + "Terraform": null + }, + { + "ROS": "PrivateIp", + "Terraform": null + }, + { + "ROS": "PublicConnectionPort", + "Terraform": null + }, + { + "ROS": "PublicConnectionString", + "Terraform": null + }, + { + "ROS": "QPS", + "Terraform": null + }, + { + "ROS": "ResourceGroupId", + "Terraform": null + }, + { + "ROS": "VpcId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VpcPrivateConnectionPort", + "Terraform": null + }, + { + "ROS": "VpcPrivateConnectionString", + "Terraform": null + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "ZoneId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::REDIS::PrepayInstance", + "Terraform": null + }, + "ProductCode": "kvstore", + "Name": { + "zh": "Redis预付费实例", + "en": "Subscription Tair (Redis OSS-compatible) Instance" + }, + "Properties": [ + { + "ROS": "AutoPay", + "Terraform": null, + "Required": false + }, + { + "ROS": "AutoRenewDuration", + "Terraform": null, + "Required": false + }, + { + "ROS": "BackupPolicy", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "EnableBackupLog", + "Terraform": null, + "Required": false + }, + { + "ROS": "PreferredBackupPeriod", + "Terraform": null, + "Required": true + }, + { + "ROS": "PreferredBackupTime", + "Terraform": null, + "Required": true + } + ] + }, + { + "ROS": "Connections", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "ClassicInnerConnection", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "ConnectionPort", + "Terraform": null, + "Required": true + }, + { + "ROS": "ConnectionString", + "Terraform": null, + "Required": true + } + ] + }, + { + "ROS": "DirectConnection", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "ConnectionPort", + "Terraform": null, + "Required": true + }, + { + "ROS": "ConnectionString", + "Terraform": null, + "Required": true + } + ] + }, + { + "ROS": "PublicConnection", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "ConnectionPort", + "Terraform": null, + "Required": true + }, + { + "ROS": "ConnectionString", + "Terraform": null, + "Required": true + } + ] + }, + { + "ROS": "VpcPrivateConnection", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "ConnectionPort", + "Terraform": null, + "Required": true + }, + { + "ROS": "ConnectionString", + "Terraform": null, + "Required": true + } + ] + } + ] + }, + { + "ROS": "DeletionForce", + "Terraform": null, + "Required": false + }, + { + "ROS": "DeletionProtection", + "Terraform": null, + "Required": false + }, + { + "ROS": "EngineVersion", + "Terraform": null, + "Required": false + }, + { + "ROS": "EvictionPolicy", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceClass", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceMaintainTime", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "MaintainEndTime", + "Terraform": null, + "Required": false + }, + { + "ROS": "MaintainStartTime", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "InstanceName", + "Terraform": null, + "Required": false + }, + { + "ROS": "NodeType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Password", + "Terraform": null, + "Required": false + }, + { + "ROS": "Period", + "Terraform": null, + "Required": false + }, + { + "ROS": "PeriodUnit", + "Terraform": null, + "Required": false + }, + { + "ROS": "ProductType", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "SecondaryZoneId", + "Terraform": null, + "Required": false + }, + { + "ROS": "SecurityGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "ShardCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "SSLEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "TairConfig", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "ShardCount", + "Terraform": null, + "Required": false + }, + { + "ROS": "Storage", + "Terraform": null, + "Required": false + }, + { + "ROS": "StorageType", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "VpcId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VpcPasswordFree", + "Terraform": null, + "Required": false + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "ZoneId", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "ArchitectureType", + "Terraform": null + }, + { + "ROS": "Bandwidth", + "Terraform": null + }, + { + "ROS": "Capacity", + "Terraform": null + }, + { + "ROS": "ChargeType", + "Terraform": null + }, + { + "ROS": "ClassicInnerConnectionPort", + "Terraform": null + }, + { + "ROS": "ClassicInnerConnectionString", + "Terraform": null + }, + { + "ROS": "ConnectionDomain", + "Terraform": null + }, + { + "ROS": "Connections", + "Terraform": null + }, + { + "ROS": "DirectConnectionPort", + "Terraform": null + }, + { + "ROS": "DirectConnectionString", + "Terraform": null + }, + { + "ROS": "EngineVersion", + "Terraform": null + }, + { + "ROS": "HasRenewChangeOrder", + "Terraform": null + }, + { + "ROS": "InstanceClass", + "Terraform": null + }, + { + "ROS": "InstanceId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "InstanceName", + "Terraform": null + }, + { + "ROS": "InstanceType", + "Terraform": null + }, + { + "ROS": "NetworkType", + "Terraform": null + }, + { + "ROS": "NodeType", + "Terraform": null + }, + { + "ROS": "OrderId", + "Terraform": null + }, + { + "ROS": "PackageType", + "Terraform": null + }, + { + "ROS": "Port", + "Terraform": null + }, + { + "ROS": "PrivateIp", + "Terraform": null + }, + { + "ROS": "PublicConnectionPort", + "Terraform": null + }, + { + "ROS": "PublicConnectionString", + "Terraform": null + }, + { + "ROS": "QPS", + "Terraform": null + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "VpcId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VpcPrivateConnectionPort", + "Terraform": null + }, + { + "ROS": "VpcPrivateConnectionString", + "Terraform": null + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "ZoneId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::REDIS::Whitelist", + "Terraform": null + }, + "ProductCode": "kvstore", + "Name": { + "zh": "Redis实例IP白名单", + "en": "Tair (Redis OSS-compatible) Instance IP Whitelist" + }, + "Properties": [ + { + "ROS": "InstanceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::REDIS::Instance" + } + ] + }, + { + "ROS": "SecurityIpGroupAttribute", + "Terraform": null, + "Required": false + }, + { + "ROS": "SecurityIpGroupName", + "Terraform": null, + "Required": false + }, + { + "ROS": "SecurityIps", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "SecurityIpGroupAttribute", + "Terraform": null + }, + { + "ROS": "SecurityIpGroupName", + "Terraform": null + }, + { + "ROS": "SecurityIps", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ROCKETMQ5::ConsumerGroup", + "Terraform": "alicloud_rocketmq_consumer_group" + }, + "ProductCode": "ons", + "Name": { + "zh": "ROCKETMQ5 ConsumerGroup", + "en": "ApsaraMQ for RocketMQ 5.0 Consumer Group" + }, + "Properties": [ + { + "ROS": "ConsumeRetryPolicy", + "Terraform": "consume_retry_policy", + "Required": true + }, + { + "ROS": "ConsumerGroupId", + "Terraform": "consumer_group_id", + "Required": true + }, + { + "ROS": "DeliveryOrderType", + "Terraform": "delivery_order_type", + "Required": true + }, + { + "ROS": "InstanceId", + "Terraform": "instance_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ROCKETMQ5::Instance" + } + ] + }, + { + "ROS": "Remark", + "Terraform": "remark", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "ConsumerGroupId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "DeliveryOrderType", + "Terraform": null + }, + { + "ROS": "ConsumerGroupId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "InstanceId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ROCKETMQ5::Instance", + "Terraform": "alicloud_rocketmq_instance" + }, + "ProductCode": "ons", + "Name": { + "zh": "ROCKETMQ5实例", + "en": "ApsaraMQ for RocketMQ 5.0 Instance" + }, + "Properties": [ + { + "ROS": "AutoRenew", + "Terraform": "auto_renew", + "Required": false + }, + { + "ROS": "AutoRenewPeriod", + "Terraform": "auto_renew_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "auto_renew_period_unit", + "Required": false + }, + { + "ROS": null, + "Terraform": "commodity_code", + "Required": false + }, + { + "ROS": "InstanceName", + "Terraform": "instance_name", + "Required": false + }, + { + "ROS": "InternetInfo", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "FlowOutBandwidth", + "Terraform": null, + "Required": false + }, + { + "ROS": "FlowOutType", + "Terraform": null, + "Required": false + }, + { + "ROS": "InternetSpec", + "Terraform": null, + "Required": true + }, + { + "ROS": "IpWhitelist", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + } + ] + }, + { + "ROS": null, + "Terraform": "network_info", + "Required": false + }, + { + "ROS": "PaymentType", + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": "Period", + "Terraform": "period", + "Required": false + }, + { + "ROS": "PeriodUnit", + "Terraform": "period_unit", + "Required": false + }, + { + "ROS": "ProductInfo", + "Terraform": "product_info", + "Required": true + }, + { + "ROS": "Remark", + "Terraform": "remark", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "SeriesCode", + "Terraform": "series_code", + "Required": true + }, + { + "ROS": null, + "Terraform": "service_code", + "Required": false + }, + { + "ROS": null, + "Terraform": "software", + "Required": false + }, + { + "ROS": "SubSeriesCode", + "Terraform": "sub_series_code", + "Required": true + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": "VpcInfo", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "SecurityGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "VpcId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "VSwitchIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "InstanceId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "InstanceName", + "Terraform": null + }, + { + "ROS": "InternetEndpoint", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "network_info" + }, + { + "ROS": null, + "Terraform": "product_info" + }, + { + "ROS": null, + "Terraform": "software" + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "VpcEndpoint", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ROCKETMQ5::Topic", + "Terraform": "alicloud_rocketmq_topic" + }, + "ProductCode": "ons", + "Name": { + "zh": "ROCKETMQ5 Topic", + "en": "ApsaraMQ for RocketMQ 5.0 Topic" + }, + "Properties": [ + { + "ROS": "InstanceId", + "Terraform": "instance_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ROCKETMQ5::Instance" + } + ] + }, + { + "ROS": "MessageType", + "Terraform": "message_type", + "Required": true + }, + { + "ROS": "Remark", + "Terraform": "remark", + "Required": false + }, + { + "ROS": "TopicName", + "Terraform": "topic_name", + "Required": true + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "InstanceId", + "Terraform": null + }, + { + "ROS": "MessageType", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "TopicName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ROCKETMQ::Group", + "Terraform": "alicloud_ons_group" + }, + "ProductCode": "ons", + "Name": { + "zh": "ROCKETMQ Group", + "en": "ApsaraMQ for RocketMQ Group" + }, + "Properties": [ + { + "ROS": "GroupId", + "Terraform": "group_id", + "Required": true + }, + { + "ROS": null, + "Terraform": "group_name", + "Required": false + }, + { + "ROS": "GroupType", + "Terraform": "group_type", + "Required": false + }, + { + "ROS": "InstanceId", + "Terraform": "instance_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ROCKETMQ::Instance" + } + ] + }, + { + "ROS": null, + "Terraform": "read_enable", + "Required": false + }, + { + "ROS": "Remark", + "Terraform": "remark", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "GroupId", + "Terraform": null + }, + { + "ROS": "GroupType", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "InstanceId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ROCKETMQ::Instance", + "Terraform": "alicloud_ons_instance" + }, + "ProductCode": "ons", + "Name": { + "zh": "ROCKETMQ实例", + "en": "ApsaraMQ for RocketMQ Instance" + }, + "Properties": [ + { + "ROS": "DeletionForce", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceName", + "Terraform": "instance_name", + "Required": true + }, + { + "ROS": "Remark", + "Terraform": "remark", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": "HttpInternalEndpoint", + "Terraform": null + }, + { + "ROS": "HttpInternetEndpoint", + "Terraform": null + }, + { + "ROS": "HttpInternetSecureEndpoint", + "Terraform": null + }, + { + "ROS": "InstanceId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "InstanceName", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "instance_status" + }, + { + "ROS": "InstanceType", + "Terraform": "instance_type" + }, + { + "ROS": null, + "Terraform": "release_time" + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "TcpEndpoint", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ROCKETMQ::Topic", + "Terraform": "alicloud_ons_topic" + }, + "ProductCode": "ons", + "Name": { + "zh": "ROCKETMQ Topic", + "en": "ApsaraMQ for RocketMQ Topic" + }, + "Properties": [ + { + "ROS": "InstanceId", + "Terraform": "instance_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ROCKETMQ::Instance" + } + ] + }, + { + "ROS": "MessageType", + "Terraform": "message_type", + "Required": true + }, + { + "ROS": "Remark", + "Terraform": "remark", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": "Topic", + "Terraform": "topic_name", + "Required": true + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "InstanceId", + "Terraform": null + }, + { + "ROS": "MessageType", + "Terraform": null + }, + { + "ROS": "Topic", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ResourceManager::Account", + "Terraform": "alicloud_resource_manager_account" + }, + "ProductCode": "entconsole", + "Name": { + "zh": "ResourceManager账号", + "en": "Resource Management Account" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "abandon_able_check_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "account_name_prefix", + "Required": false + }, + { + "ROS": "DeleteAccount", + "Terraform": null, + "Required": false + }, + { + "ROS": "DisplayName", + "Terraform": "display_name", + "Required": true + }, + { + "ROS": "FolderId", + "Terraform": "folder_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::Folder" + } + ] + }, + { + "ROS": "PayerAccountId", + "Terraform": "payer_account_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "DisplayName", + "Terraform": null + }, + { + "ROS": "FolderId", + "Terraform": null + }, + { + "ROS": "AccountId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "JoinMethod", + "Terraform": "join_method" + }, + { + "ROS": null, + "Terraform": "join_time" + }, + { + "ROS": null, + "Terraform": "modify_time" + }, + { + "ROS": "ResourceDirectoryId", + "Terraform": "resource_directory_id" + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "Type", + "Terraform": "type" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ResourceManager::ControlPolicy", + "Terraform": "alicloud_resource_manager_control_policy" + }, + "ProductCode": "entconsole", + "Name": { + "zh": "ResourceManager ControlPolicy", + "en": "Resource Management Control Policy" + }, + "Properties": [ + { + "ROS": "ControlPolicyName", + "Terraform": "control_policy_name", + "Required": true + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "EffectScope", + "Terraform": "effect_scope", + "Required": true + }, + { + "ROS": "PolicyDocument", + "Terraform": "policy_document", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "AttachmentCount", + "Terraform": null + }, + { + "ROS": "ControlPolicyName", + "Terraform": null + }, + { + "ROS": "Description", + "Terraform": null + }, + { + "ROS": "EffectScope", + "Terraform": null + }, + { + "ROS": "PolicyId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "PolicyDocument", + "Terraform": null + }, + { + "ROS": "PolicyType", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ResourceManager::ControlPolicyAttachment", + "Terraform": "alicloud_resource_manager_control_policy_attachment" + }, + "MainResourceType": { + "ResourceType": "ROS/ALIYUN::ResourceManager::ControlPolicy", + "RefProperty": "ROS/PolicyId" + }, + "ProductCode": "entconsole", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "PolicyId", + "Terraform": "policy_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ControlPolicy" + } + ] + }, + { + "ROS": "TargetId", + "Terraform": "target_id", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "AttachDate", + "Terraform": null + }, + { + "ROS": "Description", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "PolicyId", + "Terraform": null + }, + { + "ROS": "PolicyName", + "Terraform": null + }, + { + "ROS": "PolicyType", + "Terraform": null + }, + { + "ROS": "TargetId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ResourceManager::Folder", + "Terraform": "alicloud_resource_manager_folder" + }, + "ProductCode": "entconsole", + "Name": { + "zh": "ResourceManager Folder", + "en": "Resource Management Folder" + }, + "Properties": [ + { + "ROS": "FolderName", + "Terraform": "folder_name", + "Required": true + }, + { + "ROS": "ParentFolderId", + "Terraform": "parent_folder_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "FolderName", + "Terraform": null + }, + { + "ROS": "FolderId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "ParentFolderId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ResourceManager::Handshake", + "Terraform": "alicloud_resource_manager_handshake" + }, + "ProductCode": "entconsole", + "Name": { + "zh": "ResourceManager Handshake", + "en": "Resource Management Invitation" + }, + "Properties": [ + { + "ROS": "Note", + "Terraform": "note", + "Required": false + }, + { + "ROS": "TargetEntity", + "Terraform": "target_entity", + "Required": true + }, + { + "ROS": "TargetType", + "Terraform": "target_type", + "Required": true + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "expire_time" + }, + { + "ROS": "HandshakeId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "MasterAccountId", + "Terraform": "master_account_id" + }, + { + "ROS": "MasterAccountName", + "Terraform": "master_account_name" + }, + { + "ROS": null, + "Terraform": "modify_time" + }, + { + "ROS": "Note", + "Terraform": null + }, + { + "ROS": "ResourceDirectoryId", + "Terraform": "resource_directory_id" + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "TargetEntity", + "Terraform": null + }, + { + "ROS": "TargetType", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ResourceManager::PolicyAttachment", + "Terraform": "alicloud_resource_manager_policy_attachment" + }, + "ProductCode": "entconsole", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "PolicyName", + "Terraform": "policy_name", + "Required": true + }, + { + "ROS": "PolicyType", + "Terraform": "policy_type", + "Required": true + }, + { + "ROS": "PrincipalName", + "Terraform": "principal_name", + "Required": true + }, + { + "ROS": "PrincipalType", + "Terraform": "principal_type", + "Required": true + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + } + ], + "Attributes": [ + { + "ROS": "AttachDate", + "Terraform": null + }, + { + "ROS": "Description", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "PolicyName", + "Terraform": null + }, + { + "ROS": "PolicyType", + "Terraform": null + }, + { + "ROS": "PrincipalName", + "Terraform": null + }, + { + "ROS": "PrincipalType", + "Terraform": null + }, + { + "ROS": "ResourceGroupId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ResourceManager::ResourceDirectory", + "Terraform": "alicloud_resource_manager_resource_directory" + }, + "ProductCode": "entconsole", + "Name": { + "zh": "ResourceManager ResourceDirectory", + "en": "Resource Management Resource Directory" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "member_deletion_status", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "ResourceDirectoryId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "MasterAccountId", + "Terraform": "master_account_id" + }, + { + "ROS": "MasterAccountName", + "Terraform": "master_account_name" + }, + { + "ROS": "RootFolderId", + "Terraform": "root_folder_id" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ResourceManager::ResourceGroup", + "Terraform": "alicloud_resource_manager_resource_group" + }, + "ProductCode": "entconsole", + "Name": { + "zh": "ResourceManager资源组", + "en": "Resource Management Resource Group" + }, + "Properties": [ + { + "ROS": "DisplayName", + "Terraform": "display_name", + "Required": true + }, + { + "ROS": "Name", + "Terraform": "resource_group_name", + "Required": true + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "AccountId", + "Terraform": "account_id" + }, + { + "ROS": null, + "Terraform": "create_date" + }, + { + "ROS": "DisplayName", + "Terraform": null + }, + { + "ROS": "Id", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "Name", + "Terraform": null + }, + { + "ROS": "RegionStatuses", + "Terraform": "region_statuses" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ResourceManager::ResourceShare", + "Terraform": "alicloud_resource_manager_resource_share" + }, + "ProductCode": "entconsole", + "Name": { + "zh": "ResourceManager ResourceShare", + "en": "Resource Management Resource Share" + }, + "Properties": [ + { + "ROS": "AllowExternalTargets", + "Terraform": null, + "Required": false + }, + { + "ROS": "PermissionNames", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "Resources", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "ResourceId", + "Terraform": null, + "Required": true + }, + { + "ROS": "ResourceType", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "ResourceShareName", + "Terraform": "resource_share_name", + "Required": true + }, + { + "ROS": "Targets", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "ResourceShareId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "resource_share_owner" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ResourceManager::ResourceShareAssociation", + "Terraform": null + }, + "MainResourceType": { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceShare", + "RefProperty": "ROS/ResourceShareId" + }, + "ProductCode": "entconsole", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "PermissionNames", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "Resources", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "ResourceId", + "Terraform": null, + "Required": true + }, + { + "ROS": "ResourceType", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "ResourceShareId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceShare" + } + ] + }, + { + "ROS": "Targets", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "ResourceShareId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SAE::Application", + "Terraform": "alicloud_sae_application" + }, + "ProductCode": "sae", + "Name": { + "zh": "SAE应用", + "en": "SAE Application" + }, + "Properties": [ + { + "ROS": "AcrAssumeRoleArn", + "Terraform": "acr_assume_role_arn", + "Required": false + }, + { + "ROS": "AcrInstanceId", + "Terraform": "acr_instance_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ACR::Instance" + } + ] + }, + { + "ROS": "AppDescription", + "Terraform": "app_description", + "Required": false + }, + { + "ROS": "AppName", + "Terraform": "app_name", + "Required": true + }, + { + "ROS": "AppSource", + "Terraform": null, + "Required": false + }, + { + "ROS": "AssociateEip", + "Terraform": null, + "Required": false + }, + { + "ROS": "AutoConfig", + "Terraform": "auto_config", + "Required": false + }, + { + "ROS": null, + "Terraform": "auto_enable_application_scaling_rule", + "Required": false + }, + { + "ROS": "BaseAppId", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "batch_wait_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "change_order_desc", + "Required": false + }, + { + "ROS": "Command", + "Terraform": "command", + "Required": false + }, + { + "ROS": "CommandArgs", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "command_args_v2", + "Required": false + }, + { + "ROS": "ConfigMapMountDesc", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "config_map_mount_desc_v2", + "Required": false + }, + { + "ROS": "Cpu", + "Terraform": "cpu", + "Required": true + }, + { + "ROS": "CustomHostAlias", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "custom_host_alias_v2", + "Required": false + }, + { + "ROS": "Deploy", + "Terraform": "deploy", + "Required": false + }, + { + "ROS": "EdasContainerVersion", + "Terraform": "edas_container_version", + "Required": false + }, + { + "ROS": null, + "Terraform": "enable_ahas", + "Required": false + }, + { + "ROS": "EnableEbpf", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "enable_grey_tag_route", + "Required": false + }, + { + "ROS": "Envs", + "Terraform": "envs", + "Required": false + }, + { + "ROS": "ImagePullSecrets", + "Terraform": "image_pull_secrets", + "Required": false + }, + { + "ROS": "ImageUrl", + "Terraform": "image_url", + "Required": false + }, + { + "ROS": "JarStartArgs", + "Terraform": "jar_start_args", + "Required": false + }, + { + "ROS": "JarStartOptions", + "Terraform": "jar_start_options", + "Required": false + }, + { + "ROS": "Jdk", + "Terraform": "jdk", + "Required": false + }, + { + "ROS": "KafkaConfigs", + "Terraform": "kafka_configs", + "Required": false + }, + { + "ROS": "Liveness", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "liveness_v2", + "Required": false + }, + { + "ROS": "Memory", + "Terraform": "memory", + "Required": true + }, + { + "ROS": "MicroRegistration", + "Terraform": "micro_registration", + "Required": false + }, + { + "ROS": "MicroRegistrationConfig", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "min_ready_instance_ratio", + "Required": false + }, + { + "ROS": null, + "Terraform": "min_ready_instances", + "Required": false + }, + { + "ROS": "MountDesc", + "Terraform": "mount_desc", + "Required": false + }, + { + "ROS": "MountHost", + "Terraform": "mount_host", + "Required": false + }, + { + "ROS": "NamespaceId", + "Terraform": "namespace_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::SAE::Namespace" + } + ] + }, + { + "ROS": "NasConfigs", + "Terraform": "nas_configs", + "Required": false + }, + { + "ROS": "NasId", + "Terraform": "nas_id", + "Required": false + }, + { + "ROS": "OssAkId", + "Terraform": "oss_ak_id", + "Required": false + }, + { + "ROS": "OssAkSecret", + "Terraform": "oss_ak_secret", + "Required": false + }, + { + "ROS": "OssMountDescs", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "oss_mount_descs_v2", + "Required": false + }, + { + "ROS": "PackageType", + "Terraform": "package_type", + "Required": true + }, + { + "ROS": "PackageUrl", + "Terraform": "package_url", + "Required": false + }, + { + "ROS": "PackageVersion", + "Terraform": "package_version", + "Required": false + }, + { + "ROS": "Php", + "Terraform": "php", + "Required": false + }, + { + "ROS": "PhpArmsConfigLocation", + "Terraform": "php_arms_config_location", + "Required": false + }, + { + "ROS": "PhpConfig", + "Terraform": "php_config", + "Required": false + }, + { + "ROS": "PhpConfigLocation", + "Terraform": "php_config_location", + "Required": false + }, + { + "ROS": "PostStart", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "post_start_v2", + "Required": false + }, + { + "ROS": "PreStop", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "pre_stop_v2", + "Required": false + }, + { + "ROS": "ProgrammingLanguage", + "Terraform": "programming_language", + "Required": false + }, + { + "ROS": "PvtzDiscoverySvc", + "Terraform": "pvtz_discovery_svc", + "Required": false + }, + { + "ROS": "Python", + "Terraform": null, + "Required": false + }, + { + "ROS": "PythonModules", + "Terraform": null, + "Required": false + }, + { + "ROS": "Readiness", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "readiness_v2", + "Required": false + }, + { + "ROS": "Replicas", + "Terraform": "replicas", + "Required": true + }, + { + "ROS": "SaeVersion", + "Terraform": null, + "Required": false + }, + { + "ROS": "SecurityGroupId", + "Terraform": "security_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": "ServiceTags", + "Terraform": null, + "Required": false + }, + { + "ROS": "SlsConfigs", + "Terraform": "sls_configs", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "TerminationGracePeriodSeconds", + "Terraform": "termination_grace_period_seconds", + "Required": false + }, + { + "ROS": "Timezone", + "Terraform": "timezone", + "Required": false + }, + { + "ROS": "TomcatConfig", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "tomcat_config_v2", + "Required": false + }, + { + "ROS": null, + "Terraform": "update_strategy_v2", + "Required": false + }, + { + "ROS": null, + "Terraform": "version_id", + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "WarStartOptions", + "Terraform": "war_start_options", + "Required": false + }, + { + "ROS": "WebContainer", + "Terraform": "web_container", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "ChangeOrderId", + "Terraform": null + }, + { + "ROS": "AppId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SAE::ApplicationScalingRule", + "Terraform": "alicloud_sae_application_scaling_rule" + }, + "ProductCode": "sae", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "AppId", + "Terraform": "app_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::SAE::Application" + } + ] + }, + { + "ROS": "MinReadyInstanceRatio", + "Terraform": "min_ready_instance_ratio", + "Required": false + }, + { + "ROS": "MinReadyInstances", + "Terraform": "min_ready_instances", + "Required": false + }, + { + "ROS": "ScalingRuleEnable", + "Terraform": "scaling_rule_enable", + "Required": false + }, + { + "ROS": "ScalingRuleMetric", + "Terraform": "scaling_rule_metric", + "Required": false + }, + { + "ROS": "ScalingRuleName", + "Terraform": "scaling_rule_name", + "Required": true + }, + { + "ROS": "ScalingRuleTimer", + "Terraform": "scaling_rule_timer", + "Required": false + }, + { + "ROS": "ScalingRuleType", + "Terraform": "scaling_rule_type", + "Required": true + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "ScalingRuleName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SAE::ConfigMap", + "Terraform": "alicloud_sae_config_map" + }, + "ProductCode": "sae", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "Data", + "Terraform": "data", + "Required": true + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "Name", + "Terraform": "name", + "Required": true + }, + { + "ROS": "NamespaceId", + "Terraform": "namespace_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::SAE::Namespace" + } + ] + } + ], + "Attributes": [ + { + "ROS": "ConfigMapId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "NamespaceId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SAE::Ingress", + "Terraform": "alicloud_sae_ingress" + }, + "ProductCode": "sae", + "Name": { + "zh": "SAE Ingress", + "en": "SAE Ingress" + }, + "Properties": [ + { + "ROS": "CertId", + "Terraform": "cert_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CAS::Certificate" + } + ] + }, + { + "ROS": "CertIds", + "Terraform": "cert_ids", + "Required": false + }, + { + "ROS": "DefaultRule", + "Terraform": "default_rule", + "Required": true + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": true + }, + { + "ROS": "ListenerPort", + "Terraform": "listener_port", + "Required": true + }, + { + "ROS": "ListenerProtocol", + "Terraform": "listener_protocol", + "Required": false + }, + { + "ROS": "LoadBalanceType", + "Terraform": "load_balance_type", + "Required": false + }, + { + "ROS": "NamespaceId", + "Terraform": "namespace_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::SAE::Namespace" + } + ] + }, + { + "ROS": "Rules", + "Terraform": "rules", + "Required": true, + "Properties": [ + { + "ROS": "AppId", + "Terraform": "app_id", + "Required": true + }, + { + "ROS": null, + "Terraform": "app_name", + "Required": false + }, + { + "ROS": "BackendProtocol", + "Terraform": "backend_protocol", + "Required": false + }, + { + "ROS": "ContainerPort", + "Terraform": "container_port", + "Required": true + }, + { + "ROS": "Domain", + "Terraform": "domain", + "Required": true + }, + { + "ROS": "Path", + "Terraform": "path", + "Required": true + }, + { + "ROS": "RewritePath", + "Terraform": "rewrite_path", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "SlbId", + "Terraform": "slb_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::SLB::LoadBalancer" + } + ] + } + ], + "Attributes": [ + { + "ROS": "IngressId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SAE::Namespace", + "Terraform": "alicloud_sae_namespace" + }, + "ProductCode": "sae", + "Name": { + "zh": "SAE命名空间", + "en": "SAE Namespace" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "enable_micro_registration", + "Required": false + }, + { + "ROS": "NamespaceDescription", + "Terraform": "namespace_description", + "Required": false + }, + { + "ROS": "NamespaceId", + "Terraform": "namespace_id", + "Required": true + }, + { + "ROS": "NamespaceName", + "Terraform": "namespace_name", + "Required": true + }, + { + "ROS": null, + "Terraform": "namespace_short_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "NamespaceId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SAE::SlbBinding", + "Terraform": null + }, + "ProductCode": "sae", + "Name": { + "zh": "为SAE应用绑定SLB", + "en": "Associate SLB Instance with SAE Application" + }, + "Properties": [ + { + "ROS": "AppId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::SAE::Application" + } + ] + }, + { + "ROS": "Internet", + "Terraform": null, + "Required": false + }, + { + "ROS": "InternetSlbId", + "Terraform": null, + "Required": false + }, + { + "ROS": "Intranet", + "Terraform": null, + "Required": false + }, + { + "ROS": "IntranetSlbId", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "AppId", + "Terraform": null + }, + { + "ROS": "ChangeOrderId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SAG::ACL", + "Terraform": "alicloud_sag_acl" + }, + "ProductCode": "smartag", + "Name": { + "zh": "SAG访问控制", + "en": "SAG ACL" + }, + "Properties": [ + { + "ROS": "Name", + "Terraform": "name", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "AclId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SAG::ACLAssociation", + "Terraform": null + }, + "MainResourceType": { + "ResourceType": "ROS/ALIYUN::SAG::ACL", + "RefProperty": "ROS/AclId" + }, + "ProductCode": "smartag", + "Name": { + "zh": "访问控制绑定", + "en": "Associate ACL" + }, + "Properties": [ + { + "ROS": "AclId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::SAG::ACL" + } + ] + }, + { + "ROS": "SmartAGId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::SAG::SmartAccessGateway" + } + ] + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SAG::ACLRule", + "Terraform": "alicloud_sag_acl_rule" + }, + "ProductCode": "smartag", + "Name": { + "zh": "SAG访问控制规则", + "en": "SAG ACL Rule" + }, + "Properties": [ + { + "ROS": "AclId", + "Terraform": "acl_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::SAG::ACL" + } + ] + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "DestCidr", + "Terraform": "dest_cidr", + "Required": true + }, + { + "ROS": "DestPortRange", + "Terraform": "dest_port_range", + "Required": true + }, + { + "ROS": "Direction", + "Terraform": "direction", + "Required": true + }, + { + "ROS": "DpiGroupIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "DpiSignatureIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "IpProtocol", + "Terraform": "ip_protocol", + "Required": true + }, + { + "ROS": "Name", + "Terraform": null, + "Required": false + }, + { + "ROS": "Policy", + "Terraform": "policy", + "Required": true + }, + { + "ROS": "Priority", + "Terraform": "priority", + "Required": false + }, + { + "ROS": "SourceCidr", + "Terraform": "source_cidr", + "Required": true + }, + { + "ROS": "SourcePortRange", + "Terraform": "source_port_range", + "Required": true + }, + { + "ROS": "Type", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "AcrId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SAG::App", + "Terraform": null + }, + "ProductCode": "smartag", + "Name": { + "zh": "智能接入网关APP", + "en": "SAG App" + }, + "Properties": [ + { + "ROS": "AutoPay", + "Terraform": null, + "Required": true + }, + { + "ROS": "ChargeType", + "Terraform": null, + "Required": false + }, + { + "ROS": "DataPlan", + "Terraform": null, + "Required": true + }, + { + "ROS": "Period", + "Terraform": null, + "Required": true + }, + { + "ROS": "UserCount", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "OrderId", + "Terraform": null + }, + { + "ROS": "SmartAGId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SAG::AppUser", + "Terraform": null + }, + "ProductCode": "smartag", + "Name": { + "zh": "SAG用户", + "en": "SAG User" + }, + "Properties": [ + { + "ROS": "Bandwidth", + "Terraform": null, + "Required": true + }, + { + "ROS": "ClientIp", + "Terraform": null, + "Required": false + }, + { + "ROS": "Disable", + "Terraform": null, + "Required": false + }, + { + "ROS": "Password", + "Terraform": null, + "Required": false + }, + { + "ROS": "SmartAGId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::SAG::SmartAccessGateway" + } + ], + "Required": true + }, + { + "ROS": "UserMail", + "Terraform": null, + "Required": true + }, + { + "ROS": "UserName", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "SmartAGId", + "Terraform": null + }, + { + "ROS": "UserName", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SAG::CloudConnectNetwork", + "Terraform": "alicloud_cloud_connect_network" + }, + "ProductCode": "smartag", + "Name": { + "zh": "云连接网", + "en": "CCN Instance" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "cidr_block", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "IsDefault", + "Terraform": "is_default", + "Required": false + }, + { + "ROS": "Name", + "Terraform": "name", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": true + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": "CcnId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SAG::GrantCcnToCen", + "Terraform": "alicloud_cloud_connect_network_grant" + }, + "ProductCode": "smartag", + "Name": { + "zh": "授权给云连接网", + "en": "Authorize CCN Instance" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "ccn_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::SAG::CloudConnectNetwork" + } + ] + }, + { + "ROS": "CcnInstanceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::SAG::CloudConnectNetwork" + } + ] + }, + { + "ROS": null, + "Terraform": "cen_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::CenInstance" + } + ] + }, + { + "ROS": "CenInstanceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::CenInstance" + } + ] + }, + { + "ROS": "CenUid", + "Terraform": "cen_uid", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "CcnInstanceId", + "Terraform": null + }, + { + "ROS": "CenInstanceId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SAG::Qos", + "Terraform": "alicloud_sag_qos" + }, + "ProductCode": "smartag", + "Name": { + "zh": "QoS策略实例", + "en": "QoS Policy" + }, + "Properties": [ + { + "ROS": "QosName", + "Terraform": "name", + "Required": true + }, + { + "ROS": "QosDescription", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "QosId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SAG::QosAssociation", + "Terraform": null + }, + "MainResourceType": { + "ResourceType": "ROS/ALIYUN::SAG::Qos", + "RefProperty": "ROS/QosId" + }, + "ProductCode": "smartag", + "Name": { + "zh": "QoS策略实例绑定", + "en": "Attach QoS Policy" + }, + "Properties": [ + { + "ROS": "QosId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::SAG::Qos" + } + ] + }, + { + "ROS": "SmartAGId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::SAG::SmartAccessGateway" + } + ] + } + ], + "Attributes": [ + { + "ROS": "QosId", + "Terraform": null + }, + { + "ROS": "SmartAGId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SAG::QosCar", + "Terraform": "alicloud_sag_qos_car" + }, + "ProductCode": "smartag", + "Name": { + "zh": "QoS限速规则", + "en": "QoS Traffic Throttling Rule" + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "LimitType", + "Terraform": "limit_type", + "Required": true + }, + { + "ROS": "MaxBandwidthAbs", + "Terraform": "max_bandwidth_abs", + "Required": false + }, + { + "ROS": "MaxBandwidthPercent", + "Terraform": "max_bandwidth_percent", + "Required": false + }, + { + "ROS": "MinBandwidthAbs", + "Terraform": "min_bandwidth_abs", + "Required": false + }, + { + "ROS": "MinBandwidthPercent", + "Terraform": "min_bandwidth_percent", + "Required": false + }, + { + "ROS": "Name", + "Terraform": "name", + "Required": false + }, + { + "ROS": "PercentSourceType", + "Terraform": "percent_source_type", + "Required": false + }, + { + "ROS": "Priority", + "Terraform": "priority", + "Required": true + }, + { + "ROS": "QosId", + "Terraform": "qos_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::SAG::Qos" + } + ] + } + ], + "Attributes": [ + { + "ROS": "QosCarId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SAG::QosPolicy", + "Terraform": "alicloud_sag_qos_policy" + }, + "ProductCode": "smartag", + "Name": { + "zh": "QoS策略流分类规则", + "en": "QoS Traffic Classification Rule" + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "DestCidr", + "Terraform": "dest_cidr", + "Required": true + }, + { + "ROS": "DestPortRange", + "Terraform": "dest_port_range", + "Required": true + }, + { + "ROS": "DpiGroupIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "DpiSignatureIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "EndTime", + "Terraform": "end_time", + "Required": false + }, + { + "ROS": "IpProtocol", + "Terraform": "ip_protocol", + "Required": true + }, + { + "ROS": "Name", + "Terraform": "name", + "Required": false + }, + { + "ROS": "Priority", + "Terraform": "priority", + "Required": true + }, + { + "ROS": "QosId", + "Terraform": "qos_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::SAG::Qos" + } + ] + }, + { + "ROS": "SourceCidr", + "Terraform": "source_cidr", + "Required": true + }, + { + "ROS": "SourcePortRange", + "Terraform": "source_port_range", + "Required": true + }, + { + "ROS": "StartTime", + "Terraform": "start_time", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "QosPolicyId", + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SAG::SerialNumberBinding", + "Terraform": null + }, + "ProductCode": "smartag", + "Name": { + "zh": "硬件设备绑定", + "en": "Bind SAG Device" + }, + "Properties": [ + { + "ROS": "SerialNumber", + "Terraform": null, + "Required": true + }, + { + "ROS": "SmartAGId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::SAG::SmartAccessGateway" + } + ] + } + ], + "Attributes": [ + { + "ROS": "SmartAGId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SAG::SmartAccessGateway", + "Terraform": null + }, + "ProductCode": "smartag", + "Name": { + "zh": "智能接入网关实例", + "en": "SAG Instance" + }, + "Properties": [ + { + "ROS": "Activate", + "Terraform": null, + "Required": false + }, + { + "ROS": "AlreadyHaveSag", + "Terraform": null, + "Required": false + }, + { + "ROS": "AutoPay", + "Terraform": null, + "Required": false + }, + { + "ROS": "BuyerMessage", + "Terraform": null, + "Required": true + }, + { + "ROS": "ChargeType", + "Terraform": null, + "Required": true + }, + { + "ROS": "CidrBlock", + "Terraform": null, + "Required": false + }, + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "HardWareSpec", + "Terraform": null, + "Required": true + }, + { + "ROS": "HaType", + "Terraform": null, + "Required": true + }, + { + "ROS": "MaxBandWidth", + "Terraform": null, + "Required": true + }, + { + "ROS": "Name", + "Terraform": null, + "Required": false + }, + { + "ROS": "Period", + "Terraform": null, + "Required": true + }, + { + "ROS": "ReceiverAddress", + "Terraform": null, + "Required": true + }, + { + "ROS": "ReceiverCity", + "Terraform": null, + "Required": true + }, + { + "ROS": "ReceiverCountry", + "Terraform": null, + "Required": true + }, + { + "ROS": "ReceiverDistrict", + "Terraform": null, + "Required": true + }, + { + "ROS": "ReceiverEmail", + "Terraform": null, + "Required": true + }, + { + "ROS": "ReceiverMobile", + "Terraform": null, + "Required": true + }, + { + "ROS": "ReceiverName", + "Terraform": null, + "Required": true + }, + { + "ROS": "ReceiverPhone", + "Terraform": null, + "Required": false + }, + { + "ROS": "ReceiverState", + "Terraform": null, + "Required": true + }, + { + "ROS": "ReceiverTown", + "Terraform": null, + "Required": true + }, + { + "ROS": "ReceiverZip", + "Terraform": null, + "Required": true + }, + { + "ROS": "RoutingStrategy", + "Terraform": null, + "Required": false + }, + { + "ROS": "SecurityLockThreshold", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "OrderId", + "Terraform": null + }, + { + "ROS": "SmartAGId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SAG::SmartAccessGatewayBinding", + "Terraform": "alicloud_cloud_connect_network_attachment" + }, + "ProductCode": "smartag", + "Name": { + "zh": "绑定到云连接网", + "en": "Bind to CCN Instance" + }, + "Properties": [ + { + "ROS": "CcnId", + "Terraform": "ccn_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::SAG::CloudConnectNetwork" + } + ] + }, + { + "ROS": null, + "Terraform": "sag_id", + "Required": false + }, + { + "ROS": "SmartAGId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::SAG::SmartAccessGateway" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "SmartAGId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SAS::Instance", + "Terraform": null + }, + "ProductCode": "sas", + "Name": { + "zh": "SAS Instance", + "en": "Security Center Instance" + }, + "Properties": [ + { + "ROS": "AntiRansomware", + "Terraform": null, + "Required": false + }, + { + "ROS": "AntiRansomwareManageService", + "Terraform": null, + "Required": false + }, + { + "ROS": "AutoPay", + "Terraform": null, + "Required": false + }, + { + "ROS": "AutoRenew", + "Terraform": null, + "Required": false + }, + { + "ROS": "CloudHoneypot", + "Terraform": null, + "Required": false + }, + { + "ROS": "ConfigurationAssessment", + "Terraform": null, + "Required": false + }, + { + "ROS": "ContainerImageScan", + "Terraform": null, + "Required": false + }, + { + "ROS": "Edition", + "Terraform": null, + "Required": false + }, + { + "ROS": "LogAnalysis", + "Terraform": null, + "Required": false + }, + { + "ROS": "MaliciousFileDetectionSDK", + "Terraform": null, + "Required": false + }, + { + "ROS": "Period", + "Terraform": null, + "Required": true + }, + { + "ROS": "PeriodUnit", + "Terraform": null, + "Required": true + }, + { + "ROS": "ProtectedServers", + "Terraform": null, + "Required": false + }, + { + "ROS": "QuotaForApplicationProtection", + "Terraform": null, + "Required": false + }, + { + "ROS": "QuotaForCloudHoneypot", + "Terraform": null, + "Required": false + }, + { + "ROS": "QuotaForConfigurationAssessment", + "Terraform": null, + "Required": false + }, + { + "ROS": "QuotaForMaliciousFileDetectionSDK", + "Terraform": null, + "Required": false + }, + { + "ROS": "QuotaForVulnerabilityFixing", + "Terraform": null, + "Required": false + }, + { + "ROS": "QuotaForWebTamperProofing", + "Terraform": null, + "Required": false + }, + { + "ROS": "ThreatAnalysis", + "Terraform": null, + "Required": false + }, + { + "ROS": "ThreatAnalysisLogStorageCapacity", + "Terraform": null, + "Required": false + }, + { + "ROS": "VCore", + "Terraform": null, + "Required": false + }, + { + "ROS": "VulnerabilityFixing", + "Terraform": null, + "Required": false + }, + { + "ROS": "WebTamperProtection", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "InstanceId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SWAS::Instance", + "Terraform": "alicloud_simple_application_server_instance" + }, + "ProductCode": "swas", + "Name": { + "zh": "轻量应用服务器实例", + "en": "Simple Application Server" + }, + "Properties": [ + { + "ROS": "AutoRenew", + "Terraform": "auto_renew", + "Required": false + }, + { + "ROS": "AutoRenewPeriod", + "Terraform": "auto_renew_period", + "Required": false + }, + { + "ROS": "DataDiskSize", + "Terraform": "data_disk_size", + "Required": false + }, + { + "ROS": "ImageId", + "Terraform": "image_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::CustomImage" + } + ] + }, + { + "ROS": null, + "Terraform": "instance_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "password", + "Required": false + }, + { + "ROS": null, + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": "Period", + "Terraform": "period", + "Required": true + }, + { + "ROS": "PlanId", + "Terraform": "plan_id", + "Required": true + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "InstanceId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "InnerIpAddress", + "Terraform": null + }, + { + "ROS": "PublicIpAddress", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SWAS::Instances", + "Terraform": null + }, + "ProductCode": "swas", + "Name": { + "zh": "多台轻量应用服务器实例", + "en": "Simple Application Servers" + }, + "Properties": [ + { + "ROS": "Amount", + "Terraform": null, + "Required": false + }, + { + "ROS": "AutoRenew", + "Terraform": null, + "Required": false + }, + { + "ROS": "AutoRenewPeriod", + "Terraform": null, + "Required": false + }, + { + "ROS": "DataDiskSize", + "Terraform": null, + "Required": false + }, + { + "ROS": "ImageId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::CustomImage" + } + ] + }, + { + "ROS": "Period", + "Terraform": null, + "Required": true + }, + { + "ROS": "PlanId", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "InnerIpAddresses", + "Terraform": null + }, + { + "ROS": "InstanceIds", + "Terraform": null, + "Primary": true + }, + { + "ROS": "PublicIpAddresses", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::SearchEngine::Instance", + "Terraform": null + }, + "ProductCode": "opensearch", + "Name": { + "zh": "SearchEngine实例", + "en": "SearchEngine Instance" + }, + "Properties": [ + { + "ROS": "ChargeType", + "Terraform": null, + "Required": true + }, + { + "ROS": "Password", + "Terraform": null, + "Required": true + }, + { + "ROS": "QrsNum", + "Terraform": null, + "Required": true + }, + { + "ROS": "QrsSpec", + "Terraform": null, + "Required": true + }, + { + "ROS": "SearcherDocSize", + "Terraform": null, + "Required": true + }, + { + "ROS": "SearcherNum", + "Terraform": null, + "Required": true + }, + { + "ROS": "SearcherSpec", + "Terraform": null, + "Required": true + }, + { + "ROS": "UserName", + "Terraform": null, + "Required": true + }, + { + "ROS": "VpcId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Attributes": [ + { + "ROS": "Endpoint", + "Terraform": null + }, + { + "ROS": "InstanceId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ServerlessDev::Project", + "Terraform": null + }, + "ProductCode": "devs", + "Name": { + "zh": "ServerlessDev 项目", + "en": "Serverless Devs Project" + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "Labels", + "Terraform": null, + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "Spec", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "RoleArn", + "Terraform": null, + "Required": false + }, + { + "ROS": "TemplateConfig", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Parameters", + "Terraform": null, + "Required": false + }, + { + "ROS": "TemplateName", + "Terraform": null, + "Required": true + } + ] + } + ] + } + ], + "Attributes": [ + { + "ROS": "Name", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::TSDB::HiTSDBInstance", + "Terraform": "alicloud_tsdb_instance" + }, + "ProductCode": "hitsdb", + "Name": { + "zh": "TSDB HiTSDBInstance", + "en": "TSDB Instance" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "app_key", + "Required": false + }, + { + "ROS": "DiskCategory", + "Terraform": "disk_category", + "Required": false + }, + { + "ROS": "Duration", + "Terraform": "duration", + "Required": false + }, + { + "ROS": null, + "Terraform": "engine_type", + "Required": false + }, + { + "ROS": "InstanceAlias", + "Terraform": "instance_alias", + "Required": false + }, + { + "ROS": "InstanceClass", + "Terraform": "instance_class", + "Required": true + }, + { + "ROS": "InstanceStorage", + "Terraform": "instance_storage", + "Required": true + }, + { + "ROS": "PayType", + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": "PricingCycle", + "Terraform": null, + "Required": false + }, + { + "ROS": "SecurityIpList", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "VPCId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": "ZoneId", + "Terraform": "zone_id", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "ConnectionString", + "Terraform": null + }, + { + "ROS": "EngineType", + "Terraform": null + }, + { + "ROS": "InstanceId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "OrderId", + "Terraform": null + }, + { + "ROS": "PublicConnectionString", + "Terraform": null + }, + { + "ROS": "ReverseVpcIp", + "Terraform": null + }, + { + "ROS": "ReverseVpcPort", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::TSDB::InfluxDBDatabase", + "Terraform": null + }, + "ProductCode": "hitsdb", + "Name": { + "zh": "TSDB InfluxDBDatabase", + "en": "TSDB Database" + }, + "Properties": [ + { + "ROS": "DBName", + "Terraform": null, + "Required": true + }, + { + "ROS": "InstanceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::TSDB::HiTSDBInstance" + } + ] + } + ], + "Attributes": [ + { + "ROS": "DBName", + "Terraform": null + }, + { + "ROS": "InstanceId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::TSDB::InfluxDBUser", + "Terraform": null + }, + "ProductCode": "hitsdb", + "Name": { + "zh": "TSDB InfluxDBUser", + "en": "TSDB Database Account" + }, + "Properties": [ + { + "ROS": "DatabasePermissions", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "DBName", + "Terraform": null, + "Required": true + }, + { + "ROS": "Permission", + "Terraform": null, + "Required": true + } + ], + "Type": "list" + }, + { + "ROS": "InstanceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::TSDB::HiTSDBInstance" + } + ] + }, + { + "ROS": "Password", + "Terraform": null, + "Required": true + }, + { + "ROS": "UserName", + "Terraform": null, + "Required": true + }, + { + "ROS": "UserType", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "InstanceId", + "Terraform": null + }, + { + "ROS": "UserName", + "Terraform": null + }, + { + "ROS": "UserType", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ThreatDetection::AntiBruteForceRule", + "Terraform": "alicloud_threat_detection_anti_brute_force_rule" + }, + "ProductCode": "sas", + "Name": { + "zh": "ThreatDetection 防暴力破解规则", + "en": "TDS Brute-force Attack Defense Rule" + }, + "Properties": [ + { + "ROS": "AntiBruteForceRuleName", + "Terraform": "anti_brute_force_rule_name", + "Required": true + }, + { + "ROS": "DefaultRule", + "Terraform": "default_rule", + "Required": false + }, + { + "ROS": "FailCount", + "Terraform": "fail_count", + "Required": true + }, + { + "ROS": "ForbiddenTime", + "Terraform": "forbidden_time", + "Required": true + }, + { + "ROS": "Span", + "Terraform": "span", + "Required": true + }, + { + "ROS": "UuidList", + "Terraform": "uuid_list", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "AntiBruteForceRuleId", + "Terraform": "anti_brute_force_rule_id" + }, + { + "ROS": "AntiBruteForceRuleName", + "Terraform": null + }, + { + "ROS": "DefaultRule", + "Terraform": null + }, + { + "ROS": "FailCount", + "Terraform": null + }, + { + "ROS": "ForbiddenTime", + "Terraform": null + }, + { + "ROS": "AntiBruteForceRuleId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "Span", + "Terraform": null + }, + { + "ROS": "UuidList", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::ThreatDetection::Instance", + "Terraform": "alicloud_threat_detection_instance" + }, + "ProductCode": "sas", + "Name": { + "zh": "ThreatDetection实例", + "en": "Purchase Security Center" + }, + "Properties": [ + { + "ROS": "BuyNumber", + "Terraform": "buy_number", + "Required": false + }, + { + "ROS": "ContainerImageScan", + "Terraform": null, + "Required": false + }, + { + "ROS": "ContainerImageScanNew", + "Terraform": "container_image_scan_new", + "Required": false + }, + { + "ROS": "Honeypot", + "Terraform": "honeypot", + "Required": false + }, + { + "ROS": "HoneypotSwitch", + "Terraform": "honeypot_switch", + "Required": false + }, + { + "ROS": "ModifyType", + "Terraform": "modify_type", + "Required": false + }, + { + "ROS": "PaymentType", + "Terraform": "payment_type", + "Required": true + }, + { + "ROS": "Period", + "Terraform": "period", + "Required": false + }, + { + "ROS": "ProductType", + "Terraform": null, + "Required": false + }, + { + "ROS": "RaspCount", + "Terraform": "rasp_count", + "Required": false + }, + { + "ROS": "RenewalPeriodUnit", + "Terraform": "renewal_period_unit", + "Required": false + }, + { + "ROS": "RenewalStatus", + "Terraform": "renewal_status", + "Required": false + }, + { + "ROS": "RenewPeriod", + "Terraform": "renew_period", + "Required": false + }, + { + "ROS": "SasAntiRansomware", + "Terraform": "sas_anti_ransomware", + "Required": false + }, + { + "ROS": "SasCspm", + "Terraform": "sas_cspm", + "Required": false + }, + { + "ROS": "SasCspmSwitch", + "Terraform": "sas_cspm_switch", + "Required": false + }, + { + "ROS": "SasSc", + "Terraform": "sas_sc", + "Required": false + }, + { + "ROS": "SasSdk", + "Terraform": "sas_sdk", + "Required": false + }, + { + "ROS": "SasSdkSwitch", + "Terraform": "sas_sdk_switch", + "Required": false + }, + { + "ROS": "SasSlsStorage", + "Terraform": "sas_sls_storage", + "Required": false + }, + { + "ROS": "SasWebguardBoolean", + "Terraform": "sas_webguard_boolean", + "Required": false + }, + { + "ROS": "SasWebguardOrderNum", + "Terraform": "sas_webguard_order_num", + "Required": false + }, + { + "ROS": "ThreatAnalysis", + "Terraform": "threat_analysis", + "Required": false + }, + { + "ROS": null, + "Terraform": "threat_analysis_flow", + "Required": false + }, + { + "ROS": null, + "Terraform": "threat_analysis_sls_storage", + "Required": false + }, + { + "ROS": "ThreatAnalysisSwitch", + "Terraform": "threat_analysis_switch", + "Required": false + }, + { + "ROS": null, + "Terraform": "threat_analysis_switch1", + "Required": false + }, + { + "ROS": "VCore", + "Terraform": "v_core", + "Required": false + }, + { + "ROS": "VersionCode", + "Terraform": "version_code", + "Required": true + }, + { + "ROS": "VulCount", + "Terraform": "vul_count", + "Required": false + }, + { + "ROS": "VulSwitch", + "Terraform": "vul_switch", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "BuyNumber", + "Terraform": null + }, + { + "ROS": "ContainerImageScan", + "Terraform": null + }, + { + "ROS": "ContainerImageScanNew", + "Terraform": null + }, + { + "ROS": "CreateTime", + "Terraform": "create_time" + }, + { + "ROS": "Honeypot", + "Terraform": null + }, + { + "ROS": "HoneypotSwitch", + "Terraform": null + }, + { + "ROS": "InstanceId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "PaymentType", + "Terraform": null + }, + { + "ROS": "RaspCount", + "Terraform": null + }, + { + "ROS": "RenewalPeriodUnit", + "Terraform": null + }, + { + "ROS": "RenewalStatus", + "Terraform": null + }, + { + "ROS": "RenewPeriod", + "Terraform": null + }, + { + "ROS": "SasAntiRansomware", + "Terraform": null + }, + { + "ROS": "SasCspm", + "Terraform": null + }, + { + "ROS": "SasCspmSwitch", + "Terraform": null + }, + { + "ROS": "SasSc", + "Terraform": null + }, + { + "ROS": "SasSdk", + "Terraform": null + }, + { + "ROS": "SasSdkSwitch", + "Terraform": null + }, + { + "ROS": "SasSlsStorage", + "Terraform": null + }, + { + "ROS": "SasWebguardBoolean", + "Terraform": null + }, + { + "ROS": "SasWebguardOrderNum", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "ThreatAnalysis", + "Terraform": null + }, + { + "ROS": "ThreatAnalysisSwitch", + "Terraform": null + }, + { + "ROS": "VCore", + "Terraform": null + }, + { + "ROS": "VersionCode", + "Terraform": null + }, + { + "ROS": "VulCount", + "Terraform": null + }, + { + "ROS": "VulSwitch", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VOD::EditingProject", + "Terraform": "alicloud_vod_editing_project" + }, + "ProductCode": "vod", + "Name": { + "zh": "VOD EditingProject", + "en": "VOD Editing Project" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "cover_url", + "Required": false + }, + { + "ROS": null, + "Terraform": "division", + "Required": false + }, + { + "ROS": "EditingProjectName", + "Terraform": "editing_project_name", + "Required": false + }, + { + "ROS": "Timeline", + "Terraform": "timeline", + "Required": false + }, + { + "ROS": "Title", + "Terraform": "title", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "CreateTime", + "Terraform": null + }, + { + "ROS": "EditingProjectName", + "Terraform": null + }, + { + "ROS": "EditingProjectId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "ModifiedTime", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "Timeline", + "Terraform": null + }, + { + "ROS": "Title", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VOD::MessageCallback", + "Terraform": null + }, + "ProductCode": "vod", + "Name": { + "zh": "VOD 回调", + "en": "VOD Message Callback" + }, + "Properties": [ + { + "ROS": "AppId", + "Terraform": null, + "Required": false + }, + { + "ROS": "AuthKey", + "Terraform": null, + "Required": false + }, + { + "ROS": "AuthSwitch", + "Terraform": null, + "Required": false + }, + { + "ROS": "CallbackType", + "Terraform": null, + "Required": true + }, + { + "ROS": "CallbackUrl", + "Terraform": null, + "Required": false + }, + { + "ROS": "EventTypeList", + "Terraform": null, + "Required": false + }, + { + "ROS": "MnsEndpoint", + "Terraform": null, + "Required": false + }, + { + "ROS": "MnsQueueName", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "AppId", + "Terraform": null + }, + { + "ROS": "AuthKey", + "Terraform": null + }, + { + "ROS": "AuthSwitch", + "Terraform": null + }, + { + "ROS": "CallbackType", + "Terraform": null + }, + { + "ROS": "CallbackUrl", + "Terraform": null + }, + { + "ROS": "EventTypeList", + "Terraform": null + }, + { + "ROS": "MnsEndpoint", + "Terraform": null + }, + { + "ROS": "MnsQueueName", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VOD::Storage", + "Terraform": null + }, + "ProductCode": "vod", + "Name": { + "zh": "VOD Storage", + "en": "VOD Storage" + }, + "Properties": [ + { + "ROS": "DefaultUpload", + "Terraform": null, + "Required": false + }, + { + "ROS": "StorageLocation", + "Terraform": null, + "Required": true + }, + { + "ROS": "StorageType", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "CreateTime", + "Terraform": null + }, + { + "ROS": "DefaultUpload", + "Terraform": null + }, + { + "ROS": "GmtModified", + "Terraform": null + }, + { + "ROS": "GroupId", + "Terraform": null + }, + { + "ROS": "ResourceGroupId", + "Terraform": null + }, + { + "ROS": "StorageAcl", + "Terraform": null + }, + { + "ROS": "StorageLocation", + "Terraform": null + }, + { + "ROS": "StorageUsage", + "Terraform": null + }, + { + "ROS": "Type", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::CommonBandwidthPackage", + "Terraform": "alicloud_common_bandwidth_package" + }, + "ProductCode": "", + "Name": { + "zh": "共享带宽", + "en": "Internet Shared Bandwidth Instance" + }, + "Properties": [ + { + "ROS": "Bandwidth", + "Terraform": "bandwidth", + "Required": true + }, + { + "ROS": null, + "Terraform": "bandwidth_package_name", + "Required": false + }, + { + "ROS": "DeletionProtection", + "Terraform": "deletion_protection", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "force", + "Required": false + }, + { + "ROS": "InternetChargeType", + "Terraform": "internet_charge_type", + "Required": false + }, + { + "ROS": "ISP", + "Terraform": "isp", + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": false + }, + { + "ROS": "Ratio", + "Terraform": "ratio", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "security_protection_types", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "Zone", + "Terraform": "zone", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "BandwidthPackageId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "payment_type" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::CommonBandwidthPackageIp", + "Terraform": "alicloud_common_bandwidth_package_attachment" + }, + "ProductCode": "", + "Name": { + "zh": "共享带宽IP", + "en": "Internet Shared Bandwidth Instance IP" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "bandwidth_package_bandwidth", + "Required": false + }, + { + "ROS": "BandwidthPackageId", + "Terraform": "bandwidth_package_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::CommonBandwidthPackage" + } + ] + }, + { + "ROS": null, + "Terraform": "cancel_common_bandwidth_package_ip_bandwidth", + "Required": false + }, + { + "ROS": "Eips", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "AllocationId", + "Terraform": null, + "Required": true + }, + { + "ROS": "Bandwidth", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "ip_type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "AllocationIds", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "IpAddresses", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::ForwardEntry", + "Terraform": null + }, + "ProductCode": "nat", + "Name": { + "zh": "VPC ForwardEntry", + "en": "VPC Forward Entry" + }, + "Properties": [ + { + "ROS": "ExternalIp", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::CommonBandwidthPackageIp", + "SyncWith": "ROS/IpAddresses" + } + ] + }, + { + "ROS": "ExternalPort", + "Terraform": null, + "Required": true + }, + { + "ROS": "ForwardEntryName", + "Terraform": null, + "Required": false + }, + { + "ROS": "ForwardTableId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::NatGateway" + } + ] + }, + { + "ROS": "InternalIp", + "Terraform": null, + "Required": true + }, + { + "ROS": "InternalPort", + "Terraform": null, + "Required": true + }, + { + "ROS": "IpProtocol", + "Terraform": null, + "Required": true + }, + { + "ROS": "PortBreak", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "ForwardEntryId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::FullNatEntry", + "Terraform": null + }, + "ProductCode": "nat", + "Name": { + "zh": "VPC FullNatEntry", + "en": "VPC FULLNAT Entry" + }, + "Properties": [ + { + "ROS": "AccessIp", + "Terraform": null, + "Required": true + }, + { + "ROS": "AccessPort", + "Terraform": null, + "Required": true + }, + { + "ROS": "FullNatEntryDescription", + "Terraform": null, + "Required": false + }, + { + "ROS": "FullNatEntryName", + "Terraform": null, + "Required": false + }, + { + "ROS": "FullNatTableId", + "Terraform": null, + "Required": true + }, + { + "ROS": "IpProtocol", + "Terraform": null, + "Required": true + }, + { + "ROS": "NatIp", + "Terraform": null, + "Required": true + }, + { + "ROS": "NatIpPort", + "Terraform": null, + "Required": true + }, + { + "ROS": "NetworkInterfaceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::NetworkInterface" + } + ] + } + ], + "Attributes": [ + { + "ROS": "FullNatEntryId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::NatGateway", + "Terraform": "alicloud_nat_gateway" + }, + "ProductCode": "nat", + "Name": { + "zh": "NAT网关", + "en": "NAT Gateway" + }, + "Properties": [ + { + "ROS": "AutoPay", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "bandwidth_package_ids", + "Required": false + }, + { + "ROS": null, + "Terraform": "bandwidth_packages", + "Required": false + }, + { + "ROS": "DeletionForce", + "Terraform": null, + "Required": false + }, + { + "ROS": "DeletionProtection", + "Terraform": "deletion_protection", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": "EipBindMode", + "Terraform": "eip_bind_mode", + "Required": false + }, + { + "ROS": null, + "Terraform": "force", + "Required": false + }, + { + "ROS": "IcmpReplyEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "InternetChargeType", + "Terraform": null, + "Required": false + }, + { + "ROS": "NatGatewayName", + "Terraform": "nat_gateway_name", + "Required": false + }, + { + "ROS": "NatType", + "Terraform": null, + "Required": false + }, + { + "ROS": "NetworkType", + "Terraform": "network_type", + "Required": false + }, + { + "ROS": "InstanceChargeType", + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": "Duration", + "Terraform": "period", + "Required": false + }, + { + "ROS": "PricingCycle", + "Terraform": null, + "Required": false + }, + { + "ROS": "SecurityProtectionEnabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "Spec", + "Terraform": "specification", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Attributes": [ + { + "ROS": "ForwardTableId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "forward_table_ids" + }, + { + "ROS": "NatGatewayId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "SNatTableId", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "snat_table_ids" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::NatIp", + "Terraform": "alicloud_vpc_nat_ip" + }, + "ProductCode": "nat", + "Name": { + "zh": "NAT IP地址", + "en": "NAT IP Address" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": "NatGatewayId", + "Terraform": "nat_gateway_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::NatGateway" + } + ] + }, + { + "ROS": "NatIp", + "Terraform": "nat_ip", + "Required": false + }, + { + "ROS": "NatIpCidr", + "Terraform": "nat_ip_cidr", + "Required": true + }, + { + "ROS": "NatIpCidrId", + "Terraform": "nat_ip_cidr_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::NatIpCidr" + } + ] + }, + { + "ROS": "NatIpDescription", + "Terraform": "nat_ip_description", + "Required": true + }, + { + "ROS": "NatIpName", + "Terraform": "nat_ip_name", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "NatIpId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "NatIp", + "Terraform": null + }, + { + "ROS": "NatIpId", + "Terraform": "nat_ip_id" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::NatIpCidr", + "Terraform": "alicloud_vpc_nat_ip_cidr" + }, + "ProductCode": "nat", + "Name": { + "zh": "VPC NAT IP地址段", + "en": "VPC NAT IP CIDR" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": "NatGatewayId", + "Terraform": "nat_gateway_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::NatGateway" + } + ] + }, + { + "ROS": "NatIpCidr", + "Terraform": "nat_ip_cidr", + "Required": true + }, + { + "ROS": "NatIpCidrDescription", + "Terraform": "nat_ip_cidr_description", + "Required": true + }, + { + "ROS": "NatIpCidrName", + "Terraform": "nat_ip_cidr_name", + "Required": true + } + ], + "Attributes": [ + { + "ROS": "NatIpCidrId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::PublicIpAddressPool", + "Terraform": "alicloud_vpc_public_ip_address_pool" + }, + "ProductCode": "vpn", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "BizType", + "Terraform": "biz_type", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "Isp", + "Terraform": "isp", + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "public_ip_address_pool_name", + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": "resource_group_id", + "Required": false + }, + { + "ROS": "SecurityProtectionTypes", + "Terraform": "security_protection_types", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "Zones", + "Terraform": null, + "Required": false, + "Type": "list", + "Properties": {} + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "ip_address_remaining" + }, + { + "ROS": "PublicIpAddressPoolId", + "Terraform": "public_ip_address_pool_id" + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": null, + "Terraform": "total_ip_num" + }, + { + "ROS": null, + "Terraform": "used_ip_num" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::RouteTableWithGatewayAssociation", + "Terraform": null + }, + "ProductCode": "vpn", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "GatewayId", + "Terraform": null, + "Required": true + }, + { + "ROS": "GatewayType", + "Terraform": null, + "Required": true + }, + { + "ROS": "RouteTableId", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "GatewayId", + "Terraform": null + }, + { + "ROS": "RouteTableId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::SnatEntry", + "Terraform": null + }, + "ProductCode": "nat", + "Name": { + "zh": "SNAT条目", + "en": "SNAT Entry" + }, + "Properties": [ + { + "ROS": "EipAffinity", + "Terraform": null, + "Required": false + }, + { + "ROS": "SnatEntryName", + "Terraform": null, + "Required": false + }, + { + "ROS": "SnatIp", + "Terraform": null, + "Required": true + }, + { + "ROS": "SnatTableId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::NatGateway", + "SyncWith": "ROS/SNatTableId" + } + ] + }, + { + "ROS": "SourceCIDR", + "Terraform": null, + "Required": false + }, + { + "ROS": "SourceVSwitchIds", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + } + ], + "Attributes": [ + { + "ROS": "SnatEntryIds", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::VpnAttachment", + "Terraform": "alicloud_vpn_gateway_vpn_attachment" + }, + "ProductCode": "vpn", + "Name": { + "zh": "绑定转发路由器", + "en": "Associate Transit Router" + }, + "Properties": [ + { + "ROS": "AutoConfigRoute", + "Terraform": null, + "Required": false + }, + { + "ROS": "BgpConfig", + "Terraform": "bgp_config", + "Required": false + }, + { + "ROS": "CustomerGatewayId", + "Terraform": "customer_gateway_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::CustomerGateway" + } + ] + }, + { + "ROS": "EffectImmediately", + "Terraform": "effect_immediately", + "Required": false + }, + { + "ROS": "EnableDpd", + "Terraform": "enable_dpd", + "Required": false + }, + { + "ROS": "EnableNatTraversal", + "Terraform": "enable_nat_traversal", + "Required": false + }, + { + "ROS": "HealthCheckConfig", + "Terraform": "health_check_config", + "Required": false + }, + { + "ROS": "IkeConfig", + "Terraform": "ike_config", + "Required": false + }, + { + "ROS": "IpsecConfig", + "Terraform": "ipsec_config", + "Required": false + }, + { + "ROS": "LocalSubnet", + "Terraform": "local_subnet", + "Required": true + }, + { + "ROS": "Name", + "Terraform": null, + "Required": false + }, + { + "ROS": "NetworkType", + "Terraform": "network_type", + "Required": false + }, + { + "ROS": "RemoteCaCert", + "Terraform": null, + "Required": false + }, + { + "ROS": "RemoteSubnet", + "Terraform": "remote_subnet", + "Required": true + }, + { + "ROS": null, + "Terraform": "vpn_attachment_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": "VpnAttachmentId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "InternetIp", + "Terraform": "internet_ip" + }, + { + "ROS": "PeerVpnAttachmentConfig", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::VpnConnection", + "Terraform": "alicloud_vpn_connection" + }, + "ProductCode": "vpn", + "Name": { + "zh": "IPsec连接", + "en": "IPsec-VPN Connection" + }, + "Properties": [ + { + "ROS": "AutoConfigRoute", + "Terraform": "auto_config_route", + "Required": false + }, + { + "ROS": "BgpConfig", + "Terraform": "bgp_config", + "Required": false + }, + { + "ROS": "CustomerGatewayId", + "Terraform": "customer_gateway_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::CustomerGateway" + } + ] + }, + { + "ROS": "EffectImmediately", + "Terraform": "effect_immediately", + "Required": false + }, + { + "ROS": "EnableDpd", + "Terraform": "enable_dpd", + "Required": false + }, + { + "ROS": "EnableNatTraversal", + "Terraform": "enable_nat_traversal", + "Required": false + }, + { + "ROS": "EnableTunnelsBgp", + "Terraform": "enable_tunnels_bgp", + "Required": false + }, + { + "ROS": "HealthCheckConfig", + "Terraform": "health_check_config", + "Required": false + }, + { + "ROS": "IkeConfig", + "Terraform": "ike_config", + "Required": false, + "Properties": [ + { + "ROS": "IkeAuthAlg", + "Terraform": "ike_auth_alg", + "Required": false + }, + { + "ROS": "IkeEncAlg", + "Terraform": "ike_enc_alg", + "Required": false + }, + { + "ROS": "IkeLifetime", + "Terraform": "ike_lifetime", + "Required": false + }, + { + "ROS": "LocalIdIPsec", + "Terraform": "ike_local_id", + "Required": false + }, + { + "ROS": "IkeMode", + "Terraform": "ike_mode", + "Required": false + }, + { + "ROS": "IkePfs", + "Terraform": "ike_pfs", + "Required": false + }, + { + "ROS": null, + "Terraform": "ike_remote_id", + "Required": false + }, + { + "ROS": "IkeVersion", + "Terraform": "ike_version", + "Required": false + }, + { + "ROS": "Psk", + "Terraform": "psk", + "Required": false + } + ] + }, + { + "ROS": "IpsecConfig", + "Terraform": "ipsec_config", + "Required": false, + "Properties": [ + { + "ROS": "IpsecAuthAlg", + "Terraform": "ipsec_auth_alg", + "Required": false + }, + { + "ROS": "IpsecEncAlg", + "Terraform": "ipsec_enc_alg", + "Required": false + }, + { + "ROS": "IpsecLifetime", + "Terraform": "ipsec_lifetime", + "Required": false + }, + { + "ROS": "IpsecPfs", + "Terraform": "ipsec_pfs", + "Required": false + } + ] + }, + { + "ROS": "LocalSubnet", + "Terraform": "local_subnet", + "Required": true + }, + { + "ROS": "Name", + "Terraform": null, + "Required": false + }, + { + "ROS": null, + "Terraform": "network_type", + "Required": false + }, + { + "ROS": "RemoteCaCertificate", + "Terraform": null, + "Required": false + }, + { + "ROS": "RemoteSubnet", + "Terraform": "remote_subnet", + "Required": true + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": "TunnelOptionsSpecification", + "Terraform": "tunnel_options_specification", + "Required": false, + "Properties": [ + { + "ROS": "CustomerGatewayId", + "Terraform": "customer_gateway_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::CustomerGateway" + } + ] + }, + { + "ROS": "EnableDpd", + "Terraform": "enable_dpd", + "Required": false + }, + { + "ROS": "EnableNatTraversal", + "Terraform": "enable_nat_traversal", + "Required": false + }, + { + "ROS": "Role", + "Terraform": "role", + "Required": false + }, + { + "ROS": "TunnelBgpConfig", + "Terraform": "tunnel_bgp_config", + "Required": false + }, + { + "ROS": "TunnelIkeConfig", + "Terraform": "tunnel_ike_config", + "Required": false + }, + { + "ROS": "TunnelIpsecConfig", + "Terraform": "tunnel_ipsec_config", + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": null, + "Terraform": "vpn_connection_name", + "Required": false + }, + { + "ROS": "VpnGatewayId", + "Terraform": "vpn_gateway_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::VpnGateway" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "bgp_config" + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "VpnConnectionId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "PeerVpnConnectionConfig", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "resource_group_id" + }, + { + "ROS": "Status", + "Terraform": "status" + }, + { + "ROS": null, + "Terraform": "tunnel_options_specification" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::VpnGateway", + "Terraform": "alicloud_vpn_gateway" + }, + "ProductCode": "vpn", + "Name": { + "zh": "VPN网关", + "en": "VPN Gateway" + }, + "Properties": [ + { + "ROS": "AutoPay", + "Terraform": "auto_pay", + "Required": false + }, + { + "ROS": null, + "Terraform": "auto_propagate", + "Required": false + }, + { + "ROS": "Bandwidth", + "Terraform": "bandwidth", + "Required": true + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "DisasterRecoveryVSwitchId", + "Terraform": "disaster_recovery_vswitch_id", + "Required": false + }, + { + "ROS": "EnableIpsec", + "Terraform": "enable_ipsec", + "Required": false + }, + { + "ROS": "EnableSsl", + "Terraform": "enable_ssl", + "Required": false + }, + { + "ROS": "InstanceChargeType", + "Terraform": null, + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": false + }, + { + "ROS": "NetworkType", + "Terraform": "network_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": "Period", + "Terraform": "period", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "SslConnections", + "Terraform": "ssl_connections", + "Required": false + }, + { + "ROS": "Tags", + "Terraform": "tags", + "Required": false + }, + { + "ROS": "VpcId", + "Terraform": "vpc_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": null, + "Terraform": "vpn_gateway_name", + "Required": false + }, + { + "ROS": "VpnType", + "Terraform": "vpn_type", + "Required": false + }, + { + "ROS": "VSwitchId", + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Attributes": [ + { + "ROS": "Arn", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "business_status" + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": "DisasterRecoveryInternetIp", + "Terraform": "disaster_recovery_internet_ip" + }, + { + "ROS": "DisasterRecoveryVSwitchId", + "Terraform": null + }, + { + "ROS": "VpnGatewayId", + "Terraform": "id", + "Primary": true + }, + { + "ROS": "InternetIp", + "Terraform": "internet_ip" + }, + { + "ROS": "OrderId", + "Terraform": null + }, + { + "ROS": "Spec", + "Terraform": null + }, + { + "ROS": "SslMaxConnections", + "Terraform": null + }, + { + "ROS": "SslVpnInternetIp", + "Terraform": "ssl_vpn_internet_ip" + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "VpcId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": "VpnType", + "Terraform": null + }, + { + "ROS": "VSwitchId", + "Terraform": null, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::VpnPbrRouteEntry", + "Terraform": "alicloud_vpn_pbr_route_entry" + }, + "ProductCode": "vpn", + "Name": { + "zh": "VPN策略路由", + "en": "PBR for VPN Gateway" + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "NextHop", + "Terraform": "next_hop", + "Required": true + }, + { + "ROS": "OverlayMode", + "Terraform": null, + "Required": false + }, + { + "ROS": "Priority", + "Terraform": null, + "Required": false + }, + { + "ROS": "PublishVpc", + "Terraform": "publish_vpc", + "Required": true + }, + { + "ROS": "RouteDest", + "Terraform": "route_dest", + "Required": true + }, + { + "ROS": "RouteSource", + "Terraform": "route_source", + "Required": true + }, + { + "ROS": "VpnGatewayId", + "Terraform": "vpn_gateway_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::VpnGateway" + } + ] + }, + { + "ROS": "Weight", + "Terraform": "weight", + "Required": true + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "NextHop", + "Terraform": null + }, + { + "ROS": "RouteDest", + "Terraform": null + }, + { + "ROS": "RouteSource", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "VpnGatewayId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VPC::VpnRouteEntry", + "Terraform": "alicloud_vpn_route_entry" + }, + "ProductCode": "vpn", + "Name": { + "zh": "VPN目的路由", + "en": "Destination-based Route for VPN Gateway" + }, + "Properties": [ + { + "ROS": "Description", + "Terraform": null, + "Required": false + }, + { + "ROS": "NextHop", + "Terraform": "next_hop", + "Required": true + }, + { + "ROS": "OverlayMode", + "Terraform": null, + "Required": false + }, + { + "ROS": "PublishVpc", + "Terraform": "publish_vpc", + "Required": true + }, + { + "ROS": "RouteDest", + "Terraform": "route_dest", + "Required": true + }, + { + "ROS": "VpnGatewayId", + "Terraform": "vpn_gateway_id", + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::VpnGateway" + } + ] + }, + { + "ROS": "Weight", + "Terraform": "weight", + "Required": true + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": "NextHop", + "Terraform": null + }, + { + "ROS": "RouteDest", + "Terraform": null + }, + { + "ROS": null, + "Terraform": "route_entry_type" + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": "VpnGatewayId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::VS::Group", + "Terraform": "alicloud_video_surveillance_system_group" + }, + "ProductCode": "vs", + "Name": { + "zh": "VS Group", + "en": "Video Surveillance System Group" + }, + "Properties": [ + { + "ROS": "App", + "Terraform": null, + "Required": false + }, + { + "ROS": "Callback", + "Terraform": "callback", + "Required": false + }, + { + "ROS": "Description", + "Terraform": "description", + "Required": false + }, + { + "ROS": "Enabled", + "Terraform": "enabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "group_name", + "Required": false + }, + { + "ROS": "InProtocol", + "Terraform": "in_protocol", + "Required": true + }, + { + "ROS": "LazyPull", + "Terraform": null, + "Required": false + }, + { + "ROS": "Name", + "Terraform": null, + "Required": true + }, + { + "ROS": "OutProtocol", + "Terraform": "out_protocol", + "Required": true + }, + { + "ROS": "PlayDomain", + "Terraform": "play_domain", + "Required": true + }, + { + "ROS": "PushDomain", + "Terraform": "push_domain", + "Required": true + }, + { + "ROS": "Region", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "capture_image" + }, + { + "ROS": null, + "Terraform": "capture_interval" + }, + { + "ROS": null, + "Terraform": "capture_oss_bucket" + }, + { + "ROS": null, + "Terraform": "capture_oss_path" + }, + { + "ROS": null, + "Terraform": "capture_video" + }, + { + "ROS": "GbId", + "Terraform": null + }, + { + "ROS": "GbIp", + "Terraform": null + }, + { + "ROS": "GbPort", + "Terraform": null + }, + { + "ROS": "Id", + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "lazy_pull" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::WAF3::Instance", + "Terraform": null + }, + "ProductCode": "waf", + "Name": { + "zh": "WAF3实例", + "en": "WAF 3.0 Instance" + }, + "Properties": [ + { + "ROS": "AdditionalProtectionNodes", + "Terraform": null, + "Required": false + }, + { + "ROS": "ApiSecurity", + "Terraform": null, + "Required": false + }, + { + "ROS": "AutoPay", + "Terraform": null, + "Required": false + }, + { + "ROS": "AutoRenew", + "Terraform": null, + "Required": false + }, + { + "ROS": "BotAppProtection", + "Terraform": null, + "Required": false + }, + { + "ROS": "BotWebProtection", + "Terraform": null, + "Required": false + }, + { + "ROS": "DomainsExtension", + "Terraform": null, + "Required": false + }, + { + "ROS": "ElasticQps", + "Terraform": null, + "Required": false + }, + { + "ROS": "ExclusiveIPAddress", + "Terraform": null, + "Required": false + }, + { + "ROS": "FraudDetection", + "Terraform": null, + "Required": false + }, + { + "ROS": "IgnoreExisting", + "Terraform": null, + "Required": false + }, + { + "ROS": "IntelligentLoadBalancing", + "Terraform": null, + "Required": false + }, + { + "ROS": "LogService", + "Terraform": null, + "Required": false + }, + { + "ROS": "LogStorage", + "Terraform": null, + "Required": false + }, + { + "ROS": "PayType", + "Terraform": null, + "Required": true + }, + { + "ROS": "Period", + "Terraform": null, + "Required": false + }, + { + "ROS": "PeriodUnit", + "Terraform": null, + "Required": false + }, + { + "ROS": "QpsExtension", + "Terraform": null, + "Required": false + }, + { + "ROS": "Region", + "Terraform": null, + "Required": true + }, + { + "ROS": "TrafficBillingProtectionThreshold", + "Terraform": null, + "Required": false + }, + { + "ROS": "WafVersion", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "InstanceId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::WAF3::TGW", + "Terraform": null + }, + "ProductCode": "waf", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": "InstanceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::WAF3::Instance" + } + ] + }, + { + "ROS": "Listen", + "Terraform": null, + "Required": true, + "Properties": [ + { + "ROS": "Certificates", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "AppliedType", + "Terraform": null, + "Required": false + }, + { + "ROS": "CertificateId", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "CipherSuite", + "Terraform": null, + "Required": false + }, + { + "ROS": "CustomCiphers", + "Terraform": null, + "Required": false + }, + { + "ROS": "EnableTLSv3", + "Terraform": null, + "Required": false + }, + { + "ROS": "Http2Enabled", + "Terraform": null, + "Required": false + }, + { + "ROS": "Port", + "Terraform": null, + "Required": true + }, + { + "ROS": "Protocol", + "Terraform": null, + "Required": true + }, + { + "ROS": "ResourceInstanceId", + "Terraform": null, + "Required": true + }, + { + "ROS": "ResourceProduct", + "Terraform": null, + "Required": true + }, + { + "ROS": "TLSVersion", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "Redirect", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Keepalive", + "Terraform": null, + "Required": false + }, + { + "ROS": "KeepaliveRequests", + "Terraform": null, + "Required": false + }, + { + "ROS": "KeepaliveTimeout", + "Terraform": null, + "Required": false + }, + { + "ROS": "ReadTimeout", + "Terraform": null, + "Required": false + }, + { + "ROS": "RequestHeaders", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "Key", + "Terraform": null, + "Required": false + }, + { + "ROS": "Value", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "WriteTimeout", + "Terraform": null, + "Required": false + }, + { + "ROS": "XffHeaderMode", + "Terraform": null, + "Required": false + }, + { + "ROS": "XffHeaders", + "Terraform": null, + "Required": false + }, + { + "ROS": "XffProto", + "Terraform": null, + "Required": false + } + ] + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + } + ], + "Attributes": [ + { + "ROS": "InstanceId", + "Terraform": null + }, + { + "ROS": "Port", + "Terraform": null + }, + { + "ROS": "ResourceProduct", + "Terraform": null + }, + { + "ROS": "TgwId", + "Terraform": null, + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::WAF::AclRule", + "Terraform": null + }, + "ProductCode": "cbwp", + "Name": { + "zh": "WAF访问控制规则", + "en": "WAF ACL Rule" + }, + "Properties": [ + { + "ROS": "Domain", + "Terraform": null, + "Required": true + }, + { + "ROS": "InstanceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::WAF::Instance" + } + ] + }, + { + "ROS": "Region", + "Terraform": null, + "Required": false + }, + { + "ROS": "RuleId", + "Terraform": null, + "Required": false + }, + { + "ROS": "Rules", + "Terraform": null, + "Required": true + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::WAF::Domain", + "Terraform": null + }, + "ProductCode": "cbwp", + "Name": { + "zh": "WAF防护域名", + "en": "WAF Domain Protection" + }, + "Properties": [ + { + "ROS": "ClusterType", + "Terraform": null, + "Required": false + }, + { + "ROS": "ConnectionTime", + "Terraform": null, + "Required": false + }, + { + "ROS": "DomainName", + "Terraform": null, + "Required": true + }, + { + "ROS": "Http2Port", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "HttpPort", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "HttpsPort", + "Terraform": null, + "Required": false, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "HttpsRedirect", + "Terraform": null, + "Required": false + }, + { + "ROS": "HttpToUserIp", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::WAF::Instance" + } + ] + }, + { + "ROS": "IsAccessProduct", + "Terraform": null, + "Required": true + }, + { + "ROS": "LoadBalancing", + "Terraform": null, + "Required": false + }, + { + "ROS": "LogHeaders", + "Terraform": null, + "Required": false, + "Properties": [ + { + "ROS": "K", + "Terraform": null, + "Required": false + }, + { + "ROS": "V", + "Terraform": null, + "Required": false + } + ], + "Type": "list" + }, + { + "ROS": "ReadTime", + "Terraform": null, + "Required": false + }, + { + "ROS": "ResourceGroupId", + "Terraform": null, + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": "SourceIps", + "Terraform": null, + "Required": true, + "Properties": {}, + "Type": "list" + }, + { + "ROS": "WriteTime", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "ClusterType", + "Terraform": null + }, + { + "ROS": "Cname", + "Terraform": null + }, + { + "ROS": "DomainName", + "Terraform": null + }, + { + "ROS": "Http2Port", + "Terraform": null + }, + { + "ROS": "HttpPort", + "Terraform": null + }, + { + "ROS": "HttpsPort", + "Terraform": null + }, + { + "ROS": "HttpsRedirect", + "Terraform": null + }, + { + "ROS": "HttpToUserIp", + "Terraform": null + }, + { + "ROS": "InstanceId", + "Terraform": null + }, + { + "ROS": "IsAccessProduct", + "Terraform": null + }, + { + "ROS": "LoadBalancing", + "Terraform": null + }, + { + "ROS": "LogHeaders", + "Terraform": null + }, + { + "ROS": "ResourceGroupId", + "Terraform": null + }, + { + "ROS": "SourceIps", + "Terraform": null + }, + { + "ROS": "Version", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::WAF::DomainConfig", + "Terraform": null + }, + "ProductCode": "cbwp", + "Name": { + "zh": "WAF防护域名配置", + "en": "Configure WAF Domain Protection" + }, + "Properties": [ + { + "ROS": "Domain", + "Terraform": null, + "Required": true + }, + { + "ROS": "HttpPort", + "Terraform": null, + "Required": false + }, + { + "ROS": "HttpsPort", + "Terraform": null, + "Required": false + }, + { + "ROS": "HttpsRedirect", + "Terraform": null, + "Required": false + }, + { + "ROS": "HttpToUserIp", + "Terraform": null, + "Required": false + }, + { + "ROS": "InstanceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::WAF::Instance" + } + ] + }, + { + "ROS": "IsAccessProduct", + "Terraform": null, + "Required": true + }, + { + "ROS": "LoadBalancing", + "Terraform": null, + "Required": false + }, + { + "ROS": "Protocols", + "Terraform": null, + "Required": true + }, + { + "ROS": "Region", + "Terraform": null, + "Required": false + }, + { + "ROS": "RsType", + "Terraform": null, + "Required": false + }, + { + "ROS": "SourceIps", + "Terraform": null, + "Required": false + } + ], + "Attributes": [ + { + "ROS": "Cname", + "Terraform": null + }, + { + "ROS": "ProtocolType", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::WAF::Instance", + "Terraform": null + }, + "ProductCode": "cbwp", + "Name": { + "zh": "Web应用防火墙实例", + "en": "WAF Instance" + }, + "Properties": [ + { + "ROS": "BigScreen", + "Terraform": null, + "Required": true + }, + { + "ROS": "ExclusiveIpPackage", + "Terraform": null, + "Required": true + }, + { + "ROS": "ExtBandwidth", + "Terraform": null, + "Required": true + }, + { + "ROS": "ExtDomainPackage", + "Terraform": null, + "Required": true + }, + { + "ROS": "LogStorage", + "Terraform": null, + "Required": true + }, + { + "ROS": "LogTime", + "Terraform": null, + "Required": true + }, + { + "ROS": "PackageCode", + "Terraform": null, + "Required": true + }, + { + "ROS": "Period", + "Terraform": null, + "Required": false + }, + { + "ROS": "PrefessionalService", + "Terraform": null, + "Required": true + }, + { + "ROS": "RenewalStatus", + "Terraform": null, + "Required": false + }, + { + "ROS": "RenewPeriod", + "Terraform": null, + "Required": false + }, + { + "ROS": "SubscriptionType", + "Terraform": null, + "Required": true + }, + { + "ROS": "WafLog", + "Terraform": null, + "Required": true + } + ], + "Attributes": [ + { + "ROS": "EndDate", + "Terraform": null + }, + { + "ROS": "InDebt", + "Terraform": null + }, + { + "ROS": "InstanceId", + "Terraform": null, + "Primary": true + }, + { + "ROS": "RemainDay", + "Terraform": null + }, + { + "ROS": "SubscriptionType", + "Terraform": null + }, + { + "ROS": "Trial", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::WAF::LogServiceEnable", + "Terraform": null + }, + "ProductCode": "cbwp", + "Name": { + "zh": "WAF开启日志采集", + "en": "Enable Log Collection in WAF" + }, + "Properties": [ + { + "ROS": "Domain", + "Terraform": null, + "Required": true + }, + { + "ROS": "InstanceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::WAF::Instance" + } + ] + } + ], + "Attributes": [ + { + "ROS": "Domain", + "Terraform": null + }, + { + "ROS": "InstanceId", + "Terraform": null + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": "ALIYUN::WAF::WafSwitch", + "Terraform": null + }, + "ProductCode": "cbwp", + "Name": { + "zh": "Web攻击防护开关", + "en": "Web Attack Prevention Switch" + }, + "Properties": [ + { + "ROS": "Domain", + "Terraform": null, + "Required": true + }, + { + "ROS": "InstanceId", + "Terraform": null, + "Required": true, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::WAF::Instance" + } + ] + }, + { + "ROS": "Region", + "Terraform": null, + "Required": false + }, + { + "ROS": "ServiceOn", + "Terraform": null, + "Required": true + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_actiontrail_global_events_storage_region" + }, + "ProductCode": "actiontrail", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "storage_region", + "Required": false + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_actiontrail_history_delivery_job" + }, + "ProductCode": "actiontrail", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "trail_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_alb_acl_entry_attachment" + }, + "ProductCode": "alb", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "acl_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "entry", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_alb_load_balancer_common_bandwidth_package_attachment" + }, + "ProductCode": "alb", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "bandwidth_package_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": null, + "Terraform": "load_balancer_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_amqp_static_account" + }, + "ProductCode": "ons", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "access_key", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "secret_key", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "master_uid" + }, + { + "ROS": null, + "Terraform": "password" + }, + { + "ROS": null, + "Terraform": "user_name" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_arms_dispatch_rule" + }, + "ProductCode": "arms", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "dispatch_rule_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "dispatch_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "group_rules", + "Required": false + }, + { + "ROS": null, + "Terraform": "is_recover", + "Required": false + }, + { + "ROS": null, + "Terraform": "label_match_expression_grid", + "Required": false + }, + { + "ROS": null, + "Terraform": "notify_rules", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_arms_env_custom_job" + }, + "ProductCode": "arms", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "aliyun_lang", + "Required": false + }, + { + "ROS": null, + "Terraform": "config_yaml", + "Required": false + }, + { + "ROS": null, + "Terraform": "env_custom_job_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "environment_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_arms_env_pod_monitor" + }, + "ProductCode": "arms", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "aliyun_lang", + "Required": false + }, + { + "ROS": null, + "Terraform": "config_yaml", + "Required": false + }, + { + "ROS": null, + "Terraform": "environment_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "env_pod_monitor_name" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "namespace" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_arms_env_service_monitor" + }, + "ProductCode": "arms", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "aliyun_lang", + "Required": false + }, + { + "ROS": null, + "Terraform": "config_yaml", + "Required": false + }, + { + "ROS": null, + "Terraform": "environment_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "env_service_monitor_name" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "namespace" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_arms_grafana_workspace" + }, + "ProductCode": "arms", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "grafana_version", + "Required": false + }, + { + "ROS": null, + "Terraform": "grafana_workspace_edition", + "Required": false + }, + { + "ROS": null, + "Terraform": "grafana_workspace_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_arms_integration_exporter" + }, + "ProductCode": "arms", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "cluster_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "integration_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "param", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "instance_id" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_arms_prometheus_alert_rule" + }, + "ProductCode": "arms", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "annotations", + "Required": false + }, + { + "ROS": null, + "Terraform": "cluster_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "dispatch_rule_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "duration", + "Required": false + }, + { + "ROS": null, + "Terraform": "expression", + "Required": false + }, + { + "ROS": null, + "Terraform": "labels", + "Required": false + }, + { + "ROS": null, + "Terraform": "message", + "Required": false + }, + { + "ROS": null, + "Terraform": "notify_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "prometheus_alert_rule_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "prometheus_alert_rule_id" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_arms_prometheus_monitoring" + }, + "ProductCode": "arms", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "cluster_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "config_yaml", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": null, + "Terraform": "type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "monitoring_name" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_arms_remote_write" + }, + "ProductCode": "arms", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "cluster_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "remote_write_yaml", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "remote_write_name" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_arms_synthetic_task" + }, + "ProductCode": "arms", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "available_assertions", + "Required": false + }, + { + "ROS": null, + "Terraform": "common_setting", + "Required": false + }, + { + "ROS": null, + "Terraform": "custom_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "frequency", + "Required": false + }, + { + "ROS": null, + "Terraform": "monitor_category", + "Required": false + }, + { + "ROS": null, + "Terraform": "monitor_conf", + "Required": false + }, + { + "ROS": null, + "Terraform": "monitors", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": null, + "Terraform": "synthetic_task_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": null, + "Terraform": "task_type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_service_mesh_extension_provider" + }, + "ProductCode": "asm", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "config", + "Required": false + }, + { + "ROS": null, + "Terraform": "extension_provider_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "service_mesh_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_service_mesh_user_permission" + }, + "ProductCode": "asm", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "permissions", + "Required": false + }, + { + "ROS": null, + "Terraform": "sub_account_user_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_api_gateway_access_control_list" + }, + "ProductCode": "apigateway", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "access_control_list_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "address_ip_version", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_api_gateway_acl_entry_attachment" + }, + "ProductCode": "apigateway", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "acl_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "comment", + "Required": false + }, + { + "ROS": null, + "Terraform": "entry", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_api_gateway_backend" + }, + "ProductCode": "apigateway", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "backend_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "backend_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "create_event_bridge_service_linked_role", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_api_gateway_instance_acl_attachment" + }, + "ProductCode": "apigateway", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "acl_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "acl_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_api_gateway_model" + }, + "ProductCode": "apigateway", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "group_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "model_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "schema", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_bastionhost_host_account" + }, + "ProductCode": "bastionhost", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "host_account_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "host_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "pass_phrase", + "Required": false + }, + { + "ROS": null, + "Terraform": "password", + "Required": false + }, + { + "ROS": null, + "Terraform": "private_key", + "Required": false + }, + { + "ROS": null, + "Terraform": "protocol_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "host_account_id" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_bastionhost_host_account_share_key_attachment" + }, + "ProductCode": "bastionhost", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "host_account_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "host_share_key_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_bastionhost_host_account_user_attachment" + }, + "ProductCode": "bastionhost", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "host_account_ids", + "Required": false + }, + { + "ROS": null, + "Terraform": "host_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "user_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_bastionhost_host_account_user_group_attachment" + }, + "ProductCode": "bastionhost", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "host_account_ids", + "Required": false + }, + { + "ROS": null, + "Terraform": "host_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "user_group_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_bastionhost_host_attachment" + }, + "ProductCode": "bastionhost", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "host_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::DEVOPS::HostGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "host_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_bastionhost_host_group" + }, + "ProductCode": "bastionhost", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "comment", + "Required": false + }, + { + "ROS": null, + "Terraform": "host_group_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "host_group_id", + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::DEVOPS::HostGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_bastionhost_host_group_account_user_attachment" + }, + "ProductCode": "bastionhost", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "host_account_names", + "Required": false + }, + { + "ROS": null, + "Terraform": "host_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::DEVOPS::HostGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "user_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_bastionhost_host_group_account_user_group_attachment" + }, + "ProductCode": "bastionhost", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "host_account_names", + "Required": false + }, + { + "ROS": null, + "Terraform": "host_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::DEVOPS::HostGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "user_group_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_bastionhost_host_share_key" + }, + "ProductCode": "bastionhost", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "host_share_key_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "pass_phrase", + "Required": false + }, + { + "ROS": null, + "Terraform": "private_key", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "host_share_key_id" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "private_key_finger_print" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_bastionhost_user" + }, + "ProductCode": "bastionhost", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "comment", + "Required": false + }, + { + "ROS": null, + "Terraform": "display_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "email", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "mobile", + "Required": false + }, + { + "ROS": null, + "Terraform": "mobile_country_code", + "Required": false + }, + { + "ROS": null, + "Terraform": "password", + "Required": false + }, + { + "ROS": null, + "Terraform": "source", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_user_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": null, + "Terraform": "user_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "user_id" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_bastionhost_user_attachment" + }, + "ProductCode": "bastionhost", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "user_group_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "user_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_bastionhost_user_group" + }, + "ProductCode": "bastionhost", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "comment", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "user_group_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "user_group_id" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_bp_studio_application" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "application_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "area_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "configuration", + "Required": false + }, + { + "ROS": null, + "Terraform": "id", + "Required": false + }, + { + "ROS": null, + "Terraform": "instances", + "Required": false + }, + { + "ROS": null, + "Terraform": "node_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "node_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "template_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "variables", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create" + }, + { + "ROS": null, + "Terraform": "delete" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_brain_industrial_pid_loop" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "pid_loop_configuration", + "Required": false + }, + { + "ROS": null, + "Terraform": "pid_loop_dcs_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "pid_loop_desc", + "Required": false + }, + { + "ROS": null, + "Terraform": "pid_loop_is_crucial", + "Required": false + }, + { + "ROS": null, + "Terraform": "pid_loop_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "pid_loop_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "pid_project_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_brain_industrial_pid_organization" + }, + "ProductCode": null, + "Name": { + "zh": "BrainIndustrial PidOrganization", + "en": "Industrial Brain PID Organization" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "parent_pid_organization_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "pid_organization_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_brain_industrial_pid_project" + }, + "ProductCode": null, + "Name": { + "zh": "BrainIndustrial PidProject", + "en": "Industrial Brain PID Project" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "pid_organization_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "pid_project_desc", + "Required": false + }, + { + "ROS": null, + "Terraform": "pid_project_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cassandra_backup_plan" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "active", + "Required": false + }, + { + "ROS": null, + "Terraform": "backup_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "backup_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "cluster_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "data_center_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "retention_period", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cassandra_cluster" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "auto_renew", + "Required": false + }, + { + "ROS": null, + "Terraform": "auto_renew_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "cluster_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "data_center_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "disk_size", + "Required": false + }, + { + "ROS": null, + "Terraform": "disk_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "ip_white", + "Required": false + }, + { + "ROS": null, + "Terraform": "maintain_end_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "maintain_start_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "major_version", + "Required": false + }, + { + "ROS": null, + "Terraform": "node_count", + "Required": false + }, + { + "ROS": null, + "Terraform": "pay_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "security_groups", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": null, + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": null, + "Terraform": "zone_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cassandra_data_center" + }, + "ProductCode": null, + "Name": { + "zh": "Cassandra数据中心", + "en": "Cassandra Data Center" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "auto_renew", + "Required": false + }, + { + "ROS": null, + "Terraform": "auto_renew_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "cluster_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "data_center_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "disk_size", + "Required": false + }, + { + "ROS": null, + "Terraform": "disk_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "node_count", + "Required": false + }, + { + "ROS": null, + "Terraform": "pay_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": null, + "Terraform": "zone_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cddc_dedicated_host_account" + }, + "ProductCode": "cddc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "account_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "account_password", + "Required": false + }, + { + "ROS": null, + "Terraform": "account_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "dedicated_host_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::DedicatedHost" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cddc_dedicated_propre_host" + }, + "ProductCode": "cddc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "auto_pay", + "Required": false + }, + { + "ROS": null, + "Terraform": "auto_renew", + "Required": false + }, + { + "ROS": null, + "Terraform": "dedicated_host_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CDDC::DedicatedHostGrou" + } + ] + }, + { + "ROS": null, + "Terraform": "ecs_class_list", + "Required": false + }, + { + "ROS": null, + "Terraform": "ecs_deployment_set_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::DeploymentSet" + } + ] + }, + { + "ROS": null, + "Terraform": "ecs_host_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "ecs_instance_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "ecs_unique_suffix", + "Required": false + }, + { + "ROS": null, + "Terraform": "ecs_zone_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "engine", + "Required": false + }, + { + "ROS": null, + "Terraform": "image_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::CustomImage" + } + ] + }, + { + "ROS": null, + "Terraform": "internet_charge_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "internet_max_bandwidth_out", + "Required": false + }, + { + "ROS": null, + "Terraform": "key_pair_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "os_password", + "Required": false + }, + { + "ROS": null, + "Terraform": "password_inherit", + "Required": false + }, + { + "ROS": null, + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "period", + "Required": false + }, + { + "ROS": null, + "Terraform": "period_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "security_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": null, + "Terraform": "user_data", + "Required": false + }, + { + "ROS": null, + "Terraform": "user_data_encoded", + "Required": false + }, + { + "ROS": null, + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": null, + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "ecs_instance_id" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cen_inter_region_traffic_qos_policy" + }, + "ProductCode": "cbn", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "inter_region_traffic_qos_policy_description", + "Required": false + }, + { + "ROS": null, + "Terraform": "inter_region_traffic_qos_policy_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "transit_router_attachment_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "transit_router_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::TransitRouter" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cen_inter_region_traffic_qos_queue" + }, + "ProductCode": "cbn", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "dscps", + "Required": false + }, + { + "ROS": null, + "Terraform": "inter_region_traffic_qos_queue_description", + "Required": false + }, + { + "ROS": null, + "Terraform": "inter_region_traffic_qos_queue_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "remain_bandwidth_percent", + "Required": false + }, + { + "ROS": null, + "Terraform": "traffic_qos_policy_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cen_private_zone" + }, + "ProductCode": "cbn", + "Name": { + "zh": "CEN PrivateZone", + "en": "CEN PrivateZone" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "access_region_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "cen_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "host_region_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "host_vpc_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cen_traffic_marking_policy" + }, + "ProductCode": "cbn", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": null, + "Terraform": "marking_dscp", + "Required": false + }, + { + "ROS": null, + "Terraform": "priority", + "Required": false + }, + { + "ROS": null, + "Terraform": "traffic_marking_policy_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "traffic_match_rules", + "Required": false + }, + { + "ROS": null, + "Terraform": "transit_router_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::TransitRouter" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": null, + "Terraform": "traffic_marking_policy_id" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cen_transit_route_table_aggregation" + }, + "ProductCode": "cbn", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "transit_route_table_aggregation_cidr", + "Required": false + }, + { + "ROS": null, + "Terraform": "transit_route_table_aggregation_description", + "Required": false + }, + { + "ROS": null, + "Terraform": "transit_route_table_aggregation_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "transit_route_table_aggregation_scope", + "Required": false + }, + { + "ROS": null, + "Terraform": "transit_route_table_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cen_transit_router_cidr" + }, + "ProductCode": "cbn", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "cidr", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "publish_cidr_route", + "Required": false + }, + { + "ROS": null, + "Terraform": "transit_router_cidr_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "transit_router_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::TransitRouter" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "transit_router_cidr_id" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cen_transit_router_ecr_attachment" + }, + "ProductCode": "cbn", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "cen_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "ecr_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "ecr_owner_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": null, + "Terraform": "transit_router_attachment_description", + "Required": false + }, + { + "ROS": null, + "Terraform": "transit_router_ecr_attachment_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "transit_router_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::TransitRouter" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cen_transit_router_grant_attachment" + }, + "ProductCode": "cbn", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "cen_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "cen_owner_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "order_type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cen_transit_router_multicast_domain" + }, + "ProductCode": "cbn", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": null, + "Terraform": "transit_router_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::TransitRouter" + } + ] + }, + { + "ROS": null, + "Terraform": "transit_router_multicast_domain_description", + "Required": false + }, + { + "ROS": null, + "Terraform": "transit_router_multicast_domain_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cen_transit_router_multicast_domain_association" + }, + "ProductCode": "cbn", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "transit_router_attachment_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "transit_router_multicast_domain_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cen_transit_router_multicast_domain_member" + }, + "ProductCode": "cbn", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": null, + "Terraform": "group_ip_address", + "Required": false + }, + { + "ROS": null, + "Terraform": "network_interface_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::NetworkInterface" + } + ] + }, + { + "ROS": null, + "Terraform": "transit_router_multicast_domain_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cen_transit_router_multicast_domain_peer_member" + }, + "ProductCode": "cbn", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": null, + "Terraform": "group_ip_address", + "Required": false + }, + { + "ROS": null, + "Terraform": "peer_transit_router_multicast_domain_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "transit_router_multicast_domain_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cen_transit_router_multicast_domain_source" + }, + "ProductCode": "cbn", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "group_ip_address", + "Required": false + }, + { + "ROS": null, + "Terraform": "network_interface_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::NetworkInterface" + } + ] + }, + { + "ROS": null, + "Terraform": "transit_router_multicast_domain_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cen_transit_router_prefix_list_association" + }, + "ProductCode": "cbn", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "next_hop", + "Required": false + }, + { + "ROS": null, + "Terraform": "next_hop_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "owner_uid", + "Required": false + }, + { + "ROS": null, + "Terraform": "prefix_list_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "transit_router_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::TransitRouter" + } + ] + }, + { + "ROS": null, + "Terraform": "transit_router_table_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_chatbot_publish_task" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "agent_key", + "Required": false + }, + { + "ROS": null, + "Terraform": "biz_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "data_id_list", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "modify_time" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cloudauth_face_config" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "biz_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "biz_type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "gmt_modified" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cloud_firewall_control_policy_order" + }, + "ProductCode": "cfw", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "acl_uuid", + "Required": false + }, + { + "ROS": null, + "Terraform": "direction", + "Required": false + }, + { + "ROS": null, + "Terraform": "order", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cloud_firewall_instance_member" + }, + "ProductCode": "cfw", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "member_desc", + "Required": false + }, + { + "ROS": null, + "Terraform": "member_uid", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "member_display_name" + }, + { + "ROS": null, + "Terraform": "modify_time" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cloud_firewall_nat_firewall" + }, + "ProductCode": "cfw", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "firewall_switch", + "Required": false + }, + { + "ROS": null, + "Terraform": "lang", + "Required": false + }, + { + "ROS": null, + "Terraform": "nat_gateway_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::VPC::NatGateway" + } + ] + }, + { + "ROS": null, + "Terraform": "nat_route_entry_list", + "Required": false + }, + { + "ROS": null, + "Terraform": "proxy_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "region_no", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": null, + "Terraform": "strict_mode", + "Required": false + }, + { + "ROS": null, + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": null, + "Terraform": "vswitch_auto", + "Required": false + }, + { + "ROS": null, + "Terraform": "vswitch_cidr", + "Required": false + }, + { + "ROS": null, + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cloud_firewall_vpc_cen_tr_firewall" + }, + "ProductCode": "cfw", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "cen_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "firewall_description", + "Required": false + }, + { + "ROS": null, + "Terraform": "firewall_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "firewall_subnet_cidr", + "Required": false + }, + { + "ROS": null, + "Terraform": "firewall_vpc_cidr", + "Required": false + }, + { + "ROS": null, + "Terraform": "region_no", + "Required": false + }, + { + "ROS": null, + "Terraform": "route_mode", + "Required": false + }, + { + "ROS": null, + "Terraform": "transit_router_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::CEN::TransitRouter" + } + ] + }, + { + "ROS": null, + "Terraform": "tr_attachment_master_cidr", + "Required": false + }, + { + "ROS": null, + "Terraform": "tr_attachment_master_zone", + "Required": false + }, + { + "ROS": null, + "Terraform": "tr_attachment_slave_cidr", + "Required": false + }, + { + "ROS": null, + "Terraform": "tr_attachment_slave_zone", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cloud_firewall_vpc_firewall" + }, + "ProductCode": "cfw", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "lang", + "Required": false + }, + { + "ROS": null, + "Terraform": "local_vpc", + "Required": false + }, + { + "ROS": null, + "Terraform": "member_uid", + "Required": false + }, + { + "ROS": null, + "Terraform": "peer_vpc", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": null, + "Terraform": "vpc_firewall_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "bandwidth" + }, + { + "ROS": null, + "Terraform": "connect_type" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "local_vpc" + }, + { + "ROS": null, + "Terraform": "peer_vpc" + }, + { + "ROS": null, + "Terraform": "region_status" + }, + { + "ROS": null, + "Terraform": "vpc_firewall_id" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cms_alarm" + }, + "ProductCode": "cms", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "composite_expression", + "Required": false + }, + { + "ROS": null, + "Terraform": "contact_groups", + "Required": false + }, + { + "ROS": null, + "Terraform": "effective_interval", + "Required": false + }, + { + "ROS": null, + "Terraform": "enabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "escalations_critical", + "Required": false + }, + { + "ROS": null, + "Terraform": "escalations_info", + "Required": false + }, + { + "ROS": null, + "Terraform": "escalations_warn", + "Required": false + }, + { + "ROS": null, + "Terraform": "metric", + "Required": false + }, + { + "ROS": null, + "Terraform": "metric_dimensions", + "Required": false + }, + { + "ROS": null, + "Terraform": "name", + "Required": false + }, + { + "ROS": null, + "Terraform": "notify_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "operator", + "Required": false + }, + { + "ROS": null, + "Terraform": "period", + "Required": false + }, + { + "ROS": null, + "Terraform": "project", + "Required": false + }, + { + "ROS": null, + "Terraform": "prometheus", + "Required": false + }, + { + "ROS": null, + "Terraform": "silence_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "statistics", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": null, + "Terraform": "targets", + "Required": false + }, + { + "ROS": null, + "Terraform": "threshold", + "Required": false + }, + { + "ROS": null, + "Terraform": "triggered_count", + "Required": false + }, + { + "ROS": null, + "Terraform": "webhook", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cloud_monitor_service_basic_public" + }, + "ProductCode": "cms", + "Name": { + "zh": null, + "en": null + }, + "Properties": [], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cloud_monitor_service_enterprise_public" + }, + "ProductCode": "cms", + "Name": { + "zh": null, + "en": null + }, + "Properties": [], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cloud_monitor_service_group_monitoring_agent_process" + }, + "ProductCode": "cms", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "alert_config", + "Required": false + }, + { + "ROS": null, + "Terraform": "group_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "match_express", + "Required": false + }, + { + "ROS": null, + "Terraform": "match_express_filter_relation", + "Required": false + }, + { + "ROS": null, + "Terraform": "process_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "group_monitoring_agent_process_id" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cloud_monitor_service_hybrid_double_write" + }, + "ProductCode": "cms", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "namespace", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_namespace", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_user_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "user_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cms_hybrid_monitor_fc_task" + }, + "ProductCode": "cms", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "namespace", + "Required": false + }, + { + "ROS": null, + "Terraform": "target_user_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "yarm_config", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "hybrid_monitor_fc_task_id" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cms_hybrid_monitor_sls_task" + }, + "ProductCode": "cms", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "attach_labels", + "Required": false + }, + { + "ROS": null, + "Terraform": "collect_interval", + "Required": false + }, + { + "ROS": null, + "Terraform": "collect_target_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "namespace", + "Required": false + }, + { + "ROS": null, + "Terraform": "sls_process_config", + "Required": false + }, + { + "ROS": null, + "Terraform": "task_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cms_metric_rule_black_list" + }, + "ProductCode": "cms", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "category", + "Required": false + }, + { + "ROS": null, + "Terraform": "effective_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "enable_end_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "enable_start_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "instances", + "Required": false + }, + { + "ROS": null, + "Terraform": "is_enable", + "Required": false + }, + { + "ROS": null, + "Terraform": "metric_rule_black_list_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "metrics", + "Required": false + }, + { + "ROS": null, + "Terraform": "namespace", + "Required": false + }, + { + "ROS": null, + "Terraform": "scope_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "scope_value", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "metric_rule_black_list_id" + }, + { + "ROS": null, + "Terraform": "update_time" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cs_autoscaling_config" + }, + "ProductCode": "acs", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "cluster_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "cool_down_duration", + "Required": false + }, + { + "ROS": null, + "Terraform": "daemonset_eviction_for_nodes", + "Required": false + }, + { + "ROS": null, + "Terraform": "expander", + "Required": false + }, + { + "ROS": null, + "Terraform": "gpu_utilization_threshold", + "Required": false + }, + { + "ROS": null, + "Terraform": "max_graceful_termination_sec", + "Required": false + }, + { + "ROS": null, + "Terraform": "min_replica_count", + "Required": false + }, + { + "ROS": null, + "Terraform": "recycle_node_deletion_enabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "scale_down_enabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "scale_up_from_zero", + "Required": false + }, + { + "ROS": null, + "Terraform": "scan_interval", + "Required": false + }, + { + "ROS": null, + "Terraform": "skip_nodes_with_local_storage", + "Required": false + }, + { + "ROS": null, + "Terraform": "skip_nodes_with_system_pods", + "Required": false + }, + { + "ROS": null, + "Terraform": "unneeded_duration", + "Required": false + }, + { + "ROS": null, + "Terraform": "utilization_threshold", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cs_kubernetes_autoscaler" + }, + "ProductCode": "acs", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "cluster_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "cool_down_duration", + "Required": false + }, + { + "ROS": null, + "Terraform": "defer_scale_in_duration", + "Required": false + }, + { + "ROS": null, + "Terraform": "nodepools", + "Required": false + }, + { + "ROS": null, + "Terraform": "use_ecs_ram_role_token", + "Required": false + }, + { + "ROS": null, + "Terraform": "utilization", + "Required": false + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cs_kubernetes_permissions" + }, + "ProductCode": "acs", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "permissions", + "Required": false + }, + { + "ROS": null, + "Terraform": "uid", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ack_one_cluster" + }, + "ProductCode": "acs", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "cluster_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "network", + "Required": false + }, + { + "ROS": null, + "Terraform": "profile", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "network" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_click_house_account" + }, + "ProductCode": "clickhouse", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "account_description", + "Required": false + }, + { + "ROS": null, + "Terraform": "account_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "account_password", + "Required": false + }, + { + "ROS": null, + "Terraform": "allow_databases", + "Required": false + }, + { + "ROS": null, + "Terraform": "allow_dictionaries", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_cluster_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "ddl_authority", + "Required": false + }, + { + "ROS": null, + "Terraform": "dml_authority", + "Required": false + }, + { + "ROS": null, + "Terraform": "type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_click_house_backup_policy" + }, + "ProductCode": "clickhouse", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "backup_retention_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_cluster_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "preferred_backup_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "preferred_backup_time", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cloud_storage_gateway_express_sync" + }, + "ProductCode": "hcs_sgw", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "bucket_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "bucket_prefix", + "Required": false + }, + { + "ROS": null, + "Terraform": "bucket_region", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "express_sync_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cloud_storage_gateway_express_sync_share_attachment" + }, + "ProductCode": "hcs_sgw", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "express_sync_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "gateway_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::APIG::Gateway" + } + ] + }, + { + "ROS": null, + "Terraform": "share_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cloud_storage_gateway_gateway" + }, + "ProductCode": "hcs_sgw", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "gateway_class", + "Required": false + }, + { + "ROS": null, + "Terraform": "gateway_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "location", + "Required": false + }, + { + "ROS": null, + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "public_network_bandwidth", + "Required": false + }, + { + "ROS": null, + "Terraform": "reason_detail", + "Required": false + }, + { + "ROS": null, + "Terraform": "reason_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "release_after_expiration", + "Required": false + }, + { + "ROS": null, + "Terraform": "storage_bundle_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "type", + "Required": false + }, + { + "ROS": null, + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cloud_storage_gateway_gateway_block_volume" + }, + "ProductCode": "hcs_sgw", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "cache_mode", + "Required": false + }, + { + "ROS": null, + "Terraform": "chap_enabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "chap_in_password", + "Required": false + }, + { + "ROS": null, + "Terraform": "chap_in_user", + "Required": false + }, + { + "ROS": null, + "Terraform": "chunk_size", + "Required": false + }, + { + "ROS": null, + "Terraform": "gateway_block_volume_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "gateway_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::APIG::Gateway" + } + ] + }, + { + "ROS": null, + "Terraform": "is_source_deletion", + "Required": false + }, + { + "ROS": null, + "Terraform": "local_path", + "Required": false + }, + { + "ROS": null, + "Terraform": "oss_bucket_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "oss_bucket_ssl", + "Required": false + }, + { + "ROS": null, + "Terraform": "oss_endpoint", + "Required": false + }, + { + "ROS": null, + "Terraform": "protocol", + "Required": false + }, + { + "ROS": null, + "Terraform": "recovery", + "Required": false + }, + { + "ROS": null, + "Terraform": "size", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "index_id" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cloud_storage_gateway_gateway_cache_disk" + }, + "ProductCode": "hcs_sgw", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "cache_disk_category", + "Required": false + }, + { + "ROS": null, + "Terraform": "cache_disk_size_in_gb", + "Required": false + }, + { + "ROS": null, + "Terraform": "gateway_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::APIG::Gateway" + } + ] + }, + { + "ROS": null, + "Terraform": "performance_level", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "cache_id" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "local_file_path" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cloud_storage_gateway_gateway_file_share" + }, + "ProductCode": "hcs_sgw", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "access_based_enumeration", + "Required": false + }, + { + "ROS": null, + "Terraform": "backend_limit", + "Required": false + }, + { + "ROS": null, + "Terraform": "browsable", + "Required": false + }, + { + "ROS": null, + "Terraform": "bypass_cache_read", + "Required": false + }, + { + "ROS": null, + "Terraform": "cache_mode", + "Required": false + }, + { + "ROS": null, + "Terraform": "direct_io", + "Required": false + }, + { + "ROS": null, + "Terraform": "download_limit", + "Required": false + }, + { + "ROS": null, + "Terraform": "fast_reclaim", + "Required": false + }, + { + "ROS": null, + "Terraform": "fe_limit", + "Required": false + }, + { + "ROS": null, + "Terraform": "gateway_file_share_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "gateway_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::APIG::Gateway" + } + ] + }, + { + "ROS": null, + "Terraform": "ignore_delete", + "Required": false + }, + { + "ROS": null, + "Terraform": "in_place", + "Required": false + }, + { + "ROS": null, + "Terraform": "lag_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "local_path", + "Required": false + }, + { + "ROS": null, + "Terraform": "nfs_v4_optimization", + "Required": false + }, + { + "ROS": null, + "Terraform": "oss_bucket_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "oss_bucket_ssl", + "Required": false + }, + { + "ROS": null, + "Terraform": "oss_endpoint", + "Required": false + }, + { + "ROS": null, + "Terraform": "partial_sync_paths", + "Required": false + }, + { + "ROS": null, + "Terraform": "path_prefix", + "Required": false + }, + { + "ROS": null, + "Terraform": "polling_interval", + "Required": false + }, + { + "ROS": null, + "Terraform": "protocol", + "Required": false + }, + { + "ROS": null, + "Terraform": "remote_sync", + "Required": false + }, + { + "ROS": null, + "Terraform": "remote_sync_download", + "Required": false + }, + { + "ROS": null, + "Terraform": "ro_client_list", + "Required": false + }, + { + "ROS": null, + "Terraform": "ro_user_list", + "Required": false + }, + { + "ROS": null, + "Terraform": "rw_client_list", + "Required": false + }, + { + "ROS": null, + "Terraform": "rw_user_list", + "Required": false + }, + { + "ROS": null, + "Terraform": "squash", + "Required": false + }, + { + "ROS": null, + "Terraform": "support_archive", + "Required": false + }, + { + "ROS": null, + "Terraform": "transfer_acceleration", + "Required": false + }, + { + "ROS": null, + "Terraform": "windows_acl", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "index_id" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cloud_storage_gateway_gateway_logging" + }, + "ProductCode": "hcs_sgw", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "gateway_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::APIG::Gateway" + } + ] + }, + { + "ROS": null, + "Terraform": "sls_logstore", + "Required": false + }, + { + "ROS": null, + "Terraform": "sls_project", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_cloud_storage_gateway_gateway_smb_user" + }, + "ProductCode": "hcs_sgw", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "gateway_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::APIG::Gateway" + } + ] + }, + { + "ROS": null, + "Terraform": "password", + "Required": false + }, + { + "ROS": null, + "Terraform": "username", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_config_aggregate_config_rule" + }, + "ProductCode": "config", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "aggregate_config_rule_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "aggregator_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::Config::Aggregator" + } + ] + }, + { + "ROS": null, + "Terraform": "config_rule_trigger_types", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "exclude_resource_ids_scope", + "Required": false + }, + { + "ROS": null, + "Terraform": "input_parameters", + "Required": false + }, + { + "ROS": null, + "Terraform": "maximum_execution_frequency", + "Required": false + }, + { + "ROS": null, + "Terraform": "region_ids_scope", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_ids_scope", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_types_scope", + "Required": false + }, + { + "ROS": null, + "Terraform": "risk_level", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_identifier", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_owner", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": null, + "Terraform": "tag_key_scope", + "Required": false + }, + { + "ROS": null, + "Terraform": "tag_value_scope", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "config_rule_id", + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::Config::Rule" + } + ] + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_config_aggregate_delivery" + }, + "ProductCode": "config", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "aggregator_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::Config::Aggregator" + } + ] + }, + { + "ROS": null, + "Terraform": "configuration_item_change_notification", + "Required": false + }, + { + "ROS": null, + "Terraform": "configuration_snapshot", + "Required": false + }, + { + "ROS": null, + "Terraform": "delivery_channel_condition", + "Required": false + }, + { + "ROS": null, + "Terraform": "delivery_channel_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "delivery_channel_target_arn", + "Required": false + }, + { + "ROS": null, + "Terraform": "delivery_channel_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "non_compliant_notification", + "Required": false + }, + { + "ROS": null, + "Terraform": "oversized_data_oss_target_arn", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "delivery_channel_id" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_config_configuration_recorder" + }, + "ProductCode": "config", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "enterprise_edition", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_types", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "organization_enable_status" + }, + { + "ROS": null, + "Terraform": "organization_master_id" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_config_delivery" + }, + "ProductCode": "config", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "configuration_item_change_notification", + "Required": false + }, + { + "ROS": null, + "Terraform": "configuration_snapshot", + "Required": false + }, + { + "ROS": null, + "Terraform": "delivery_channel_condition", + "Required": false + }, + { + "ROS": null, + "Terraform": "delivery_channel_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "delivery_channel_target_arn", + "Required": false + }, + { + "ROS": null, + "Terraform": "delivery_channel_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "non_compliant_notification", + "Required": false + }, + { + "ROS": null, + "Terraform": "oversized_data_oss_target_arn", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_config_remediation" + }, + "ProductCode": "config", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "config_rule_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::Config::Rule" + } + ] + }, + { + "ROS": null, + "Terraform": "invoke_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "params", + "Required": false + }, + { + "ROS": null, + "Terraform": "remediation_source_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "remediation_template_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "remediation_type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "remediation_id" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_das_switch_das_pro" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "sql_retention", + "Required": false + }, + { + "ROS": null, + "Terraform": "user_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_database_gateway_gateway" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "gateway_desc", + "Required": false + }, + { + "ROS": null, + "Terraform": "gateway_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_datahub_subscription" + }, + "ProductCode": "datahub", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "comment", + "Required": false + }, + { + "ROS": null, + "Terraform": "project_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "topic_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "last_modify_time" + }, + { + "ROS": null, + "Terraform": "sub_id" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_db_backup_policy" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "archive_backup_keep_count", + "Required": false + }, + { + "ROS": null, + "Terraform": "archive_backup_keep_policy", + "Required": false + }, + { + "ROS": null, + "Terraform": "archive_backup_retention_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "backup_interval", + "Required": false + }, + { + "ROS": null, + "Terraform": "backup_method", + "Required": false + }, + { + "ROS": null, + "Terraform": "backup_priority", + "Required": false + }, + { + "ROS": null, + "Terraform": "backup_retention_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "category", + "Required": false + }, + { + "ROS": null, + "Terraform": "compress_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "enable_backup_log", + "Required": false + }, + { + "ROS": null, + "Terraform": "enable_increment_data_backup", + "Required": false + }, + { + "ROS": null, + "Terraform": "high_space_usage_protection", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "local_log_retention_hours", + "Required": false + }, + { + "ROS": null, + "Terraform": "local_log_retention_space", + "Required": false + }, + { + "ROS": null, + "Terraform": "log_backup_frequency", + "Required": false + }, + { + "ROS": null, + "Terraform": "log_backup_local_retention_number", + "Required": false + }, + { + "ROS": null, + "Terraform": "log_backup_retention_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "preferred_backup_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "preferred_backup_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "released_keep_policy", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_db_read_write_splitting_connection" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "connection_prefix", + "Required": false + }, + { + "ROS": null, + "Terraform": "distribution_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "max_delay_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "port", + "Required": false + }, + { + "ROS": null, + "Terraform": "weight", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "connection_string" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_dbfs_auto_snap_shot_policy" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "policy_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "repeat_weekdays", + "Required": false + }, + { + "ROS": null, + "Terraform": "retention_days", + "Required": false + }, + { + "ROS": null, + "Terraform": "time_points", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "applied_dbfs_number" + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "last_modified" + }, + { + "ROS": null, + "Terraform": "policy_id" + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": null, + "Terraform": "status_detail" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_dbfs_instance" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "advanced_features", + "Required": false + }, + { + "ROS": null, + "Terraform": "category", + "Required": false + }, + { + "ROS": null, + "Terraform": "delete_snapshot", + "Required": false + }, + { + "ROS": null, + "Terraform": "enable_raid", + "Required": false + }, + { + "ROS": null, + "Terraform": "encryption", + "Required": false + }, + { + "ROS": null, + "Terraform": "fs_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "kms_key_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "performance_level", + "Required": false + }, + { + "ROS": null, + "Terraform": "raid_stripe_unit_number", + "Required": false + }, + { + "ROS": null, + "Terraform": "size", + "Required": false + }, + { + "ROS": null, + "Terraform": "snapshot_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Snapshot" + } + ] + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": null, + "Terraform": "used_scene", + "Required": false + }, + { + "ROS": null, + "Terraform": "zone_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_dbfs_instance_attachment" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "ecs_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_dbfs_service_linked_role" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "product_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_dbfs_snapshot" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "force", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "retention_days", + "Required": false + }, + { + "ROS": null, + "Terraform": "snapshot_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_dbs_backup_plan" + }, + "ProductCode": "cbs", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "backup_gateway_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "backup_log_interval_seconds", + "Required": false + }, + { + "ROS": null, + "Terraform": "backup_method", + "Required": false + }, + { + "ROS": null, + "Terraform": "backup_objects", + "Required": false + }, + { + "ROS": null, + "Terraform": "backup_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "backup_plan_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "backup_rate_limit", + "Required": false + }, + { + "ROS": null, + "Terraform": "backup_retention_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "backup_speed_limit", + "Required": false + }, + { + "ROS": null, + "Terraform": "backup_start_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "backup_storage_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "backup_strategy_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "cross_aliyun_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "cross_role_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "database_region", + "Required": false + }, + { + "ROS": null, + "Terraform": "database_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "duplication_archive_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "duplication_infrequent_access_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "enable_backup_log", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_class", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "oss_bucket_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "period", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "source_endpoint_database_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_endpoint_instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_endpoint_instance_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_endpoint_ip", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_endpoint_oracle_sid", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_endpoint_password", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_endpoint_port", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_endpoint_region", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_endpoint_sid", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_endpoint_user_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": null, + "Terraform": "storage_region", + "Required": false + }, + { + "ROS": null, + "Terraform": "used_time", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_dcdn_domain_config" + }, + "ProductCode": "dcdn", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "domain_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "function_args", + "Required": false + }, + { + "ROS": null, + "Terraform": "function_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "parent_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "config_id" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_dcdn_er" + }, + "ProductCode": "dcdn", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "env_conf", + "Required": false + }, + { + "ROS": null, + "Terraform": "er_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_dcdn_ipa_domain" + }, + "ProductCode": "dcdn", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "domain_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "scope", + "Required": false + }, + { + "ROS": null, + "Terraform": "sources", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_dcdn_kv" + }, + "ProductCode": "dcdn", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "key", + "Required": false + }, + { + "ROS": null, + "Terraform": "namespace", + "Required": false + }, + { + "ROS": null, + "Terraform": "value", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_dcdn_kv_namespace" + }, + "ProductCode": "dcdn", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "namespace", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_dcdn_waf_domain" + }, + "ProductCode": "dcdn", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "client_ip_tag", + "Required": false + }, + { + "ROS": null, + "Terraform": "domain_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_dcdn_waf_policy" + }, + "ProductCode": "dcdn", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "defense_scene", + "Required": false + }, + { + "ROS": null, + "Terraform": "policy_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "policy_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_dcdn_waf_policy_domain_attachment" + }, + "ProductCode": "dcdn", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "domain_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "policy_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_dcdn_waf_rule" + }, + "ProductCode": "dcdn", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "action", + "Required": false + }, + { + "ROS": null, + "Terraform": "cc_status", + "Required": false + }, + { + "ROS": null, + "Terraform": "cn_region_list", + "Required": false + }, + { + "ROS": null, + "Terraform": "conditions", + "Required": false + }, + { + "ROS": null, + "Terraform": "effect", + "Required": false + }, + { + "ROS": null, + "Terraform": "other_region_list", + "Required": false + }, + { + "ROS": null, + "Terraform": "policy_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "rate_limit", + "Required": false + }, + { + "ROS": null, + "Terraform": "regular_rules", + "Required": false + }, + { + "ROS": null, + "Terraform": "regular_types", + "Required": false + }, + { + "ROS": null, + "Terraform": "remote_addr", + "Required": false + }, + { + "ROS": null, + "Terraform": "rule_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "scenes", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": null, + "Terraform": "waf_group_ids", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "defense_scene" + }, + { + "ROS": null, + "Terraform": "gmt_modified" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ddosbgp_ip" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "ip", + "Required": false + }, + { + "ROS": null, + "Terraform": "member_uid", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ddoscoo_domain_resource" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "cert", + "Required": false + }, + { + "ROS": null, + "Terraform": "cert_identifier", + "Required": false + }, + { + "ROS": null, + "Terraform": "cert_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "cert_region", + "Required": false + }, + { + "ROS": null, + "Terraform": "domain", + "Required": false + }, + { + "ROS": null, + "Terraform": "https_ext", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_ids", + "Required": false + }, + { + "ROS": null, + "Terraform": "key", + "Required": false + }, + { + "ROS": null, + "Terraform": "ocsp_enabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "proxy_types", + "Required": false + }, + { + "ROS": null, + "Terraform": "real_servers", + "Required": false + }, + { + "ROS": null, + "Terraform": "rs_type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "cname" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ddos_basic_defense_threshold" + }, + "ProductCode": "ddos", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "bps", + "Required": false + }, + { + "ROS": null, + "Terraform": "ddos_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "internet_ip", + "Required": false + }, + { + "ROS": null, + "Terraform": "is_auto", + "Required": false + }, + { + "ROS": null, + "Terraform": "pps", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "max_bps" + }, + { + "ROS": null, + "Terraform": "max_pps" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ddos_basic_threshold" + }, + "ProductCode": "ddos", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "bps", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "internet_ip", + "Required": false + }, + { + "ROS": null, + "Terraform": "pps", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "max_bps" + }, + { + "ROS": null, + "Terraform": "max_pps" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ddos_bgp_policy" + }, + "ProductCode": "ddos", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "content", + "Required": false + }, + { + "ROS": null, + "Terraform": "policy_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_dfs_vsc_mount_point" + }, + "ProductCode": "alidfs", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "alias_prefix", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "file_system_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "instances" + }, + { + "ROS": null, + "Terraform": "mount_point_id" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_direct_mail_mail_address" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "account_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "password", + "Required": false + }, + { + "ROS": null, + "Terraform": "reply_address", + "Required": false + }, + { + "ROS": null, + "Terraform": "sendtype", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_direct_mail_receivers" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "receivers_alias", + "Required": false + }, + { + "ROS": null, + "Terraform": "receivers_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_direct_mail_tag" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "tag_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_dms_enterprise_authority_template" + }, + "ProductCode": "dms", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "authority_template_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "tid", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "authority_template_id" + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_dms_enterprise_logic_database" + }, + "ProductCode": "dms", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "alias", + "Required": false + }, + { + "ROS": null, + "Terraform": "database_ids", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "db_type" + }, + { + "ROS": null, + "Terraform": "env_type" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "logic" + }, + { + "ROS": null, + "Terraform": "logic_database_id" + }, + { + "ROS": null, + "Terraform": "owner_id_list" + }, + { + "ROS": null, + "Terraform": "owner_name_list" + }, + { + "ROS": null, + "Terraform": "schema_name" + }, + { + "ROS": null, + "Terraform": "search_name" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_dms_enterprise_proxy" + }, + "ProductCode": "dms", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "password", + "Required": false + }, + { + "ROS": null, + "Terraform": "tid", + "Required": false + }, + { + "ROS": null, + "Terraform": "username", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_dms_enterprise_proxy_access" + }, + "ProductCode": "dms", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "indep_account", + "Required": false + }, + { + "ROS": null, + "Terraform": "indep_password", + "Required": false + }, + { + "ROS": null, + "Terraform": "proxy_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "user_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "access_id" + }, + { + "ROS": null, + "Terraform": "access_secret" + }, + { + "ROS": null, + "Terraform": "gmt_create" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "instance_id" + }, + { + "ROS": null, + "Terraform": "origin_info" + }, + { + "ROS": null, + "Terraform": "proxy_access_id" + }, + { + "ROS": null, + "Terraform": "user_name" + }, + { + "ROS": null, + "Terraform": "user_uid" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_alidns_access_strategy" + }, + "ProductCode": "dns", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "access_mode", + "Required": false + }, + { + "ROS": null, + "Terraform": "default_addr_pools", + "Required": false + }, + { + "ROS": null, + "Terraform": "default_addr_pool_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "default_latency_optimization", + "Required": false + }, + { + "ROS": null, + "Terraform": "default_lba_strategy", + "Required": false + }, + { + "ROS": null, + "Terraform": "default_max_return_addr_num", + "Required": false + }, + { + "ROS": null, + "Terraform": "default_min_available_addr_num", + "Required": false + }, + { + "ROS": null, + "Terraform": "failover_addr_pools", + "Required": false + }, + { + "ROS": null, + "Terraform": "failover_addr_pool_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "failover_latency_optimization", + "Required": false + }, + { + "ROS": null, + "Terraform": "failover_lba_strategy", + "Required": false + }, + { + "ROS": null, + "Terraform": "failover_max_return_addr_num", + "Required": false + }, + { + "ROS": null, + "Terraform": "failover_min_available_addr_num", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "lang", + "Required": false + }, + { + "ROS": null, + "Terraform": "lines", + "Required": false + }, + { + "ROS": null, + "Terraform": "strategy_mode", + "Required": false + }, + { + "ROS": null, + "Terraform": "strategy_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_alidns_address_pool" + }, + "ProductCode": "dns", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "address", + "Required": false + }, + { + "ROS": null, + "Terraform": "address_pool_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "lba_strategy", + "Required": false + }, + { + "ROS": null, + "Terraform": "type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_alidns_custom_line" + }, + "ProductCode": "dns", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "custom_line_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "domain_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "ip_segment_list", + "Required": false + }, + { + "ROS": null, + "Terraform": "lang", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_alidns_domain_attachment" + }, + "ProductCode": "dns", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "domain_names", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "domain_names" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_alidns_gtm_instance" + }, + "ProductCode": "dns", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "alert_config", + "Required": false + }, + { + "ROS": null, + "Terraform": "alert_group", + "Required": false + }, + { + "ROS": null, + "Terraform": "cname_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "force_update", + "Required": false + }, + { + "ROS": null, + "Terraform": "health_check_task_count", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "lang", + "Required": false + }, + { + "ROS": null, + "Terraform": "package_edition", + "Required": false + }, + { + "ROS": null, + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "period", + "Required": false + }, + { + "ROS": null, + "Terraform": "public_cname_mode", + "Required": false + }, + { + "ROS": null, + "Terraform": "public_rr", + "Required": false + }, + { + "ROS": null, + "Terraform": "public_user_domain_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "public_zone_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "renewal_status", + "Required": false + }, + { + "ROS": null, + "Terraform": "renew_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "sms_notification_count", + "Required": false + }, + { + "ROS": null, + "Terraform": "strategy_mode", + "Required": false + }, + { + "ROS": null, + "Terraform": "ttl", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_alidns_monitor_config" + }, + "ProductCode": "dns", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "addr_pool_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "evaluation_count", + "Required": false + }, + { + "ROS": null, + "Terraform": "interval", + "Required": false + }, + { + "ROS": null, + "Terraform": "isp_city_node", + "Required": false + }, + { + "ROS": null, + "Terraform": "lang", + "Required": false + }, + { + "ROS": null, + "Terraform": "monitor_extend_info", + "Required": false + }, + { + "ROS": null, + "Terraform": "protocol_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "timeout", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_dts_consumer_channel" + }, + "ProductCode": "dts", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "consumer_group_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "consumer_group_password", + "Required": false + }, + { + "ROS": null, + "Terraform": "consumer_group_user_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "dts_instance_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "consumer_group_id" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_dts_job_monitor_rule" + }, + "ProductCode": "dts", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "delay_rule_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "dts_job_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "phone", + "Required": false + }, + { + "ROS": null, + "Terraform": "state", + "Required": false + }, + { + "ROS": null, + "Terraform": "type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_dts_migration_instance" + }, + "ProductCode": "dts", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "compute_unit", + "Required": false + }, + { + "ROS": null, + "Terraform": "database_count", + "Required": false + }, + { + "ROS": null, + "Terraform": "destination_endpoint_engine_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "destination_endpoint_region", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_class", + "Required": false + }, + { + "ROS": null, + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_endpoint_engine_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_endpoint_region", + "Required": false + }, + { + "ROS": null, + "Terraform": "sync_architecture", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "dts_instance_id" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_dts_subscription_job" + }, + "ProductCode": "dts", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "checkpoint", + "Required": false + }, + { + "ROS": null, + "Terraform": "compute_unit", + "Required": false + }, + { + "ROS": null, + "Terraform": "database_count", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_list", + "Required": false + }, + { + "ROS": null, + "Terraform": "delay_notice", + "Required": false + }, + { + "ROS": null, + "Terraform": "delay_phone", + "Required": false + }, + { + "ROS": null, + "Terraform": "delay_rule_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "destination_endpoint_engine_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "destination_region", + "Required": false + }, + { + "ROS": null, + "Terraform": "dts_instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "dts_job_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "error_notice", + "Required": false + }, + { + "ROS": null, + "Terraform": "error_phone", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_class", + "Required": false + }, + { + "ROS": null, + "Terraform": "payment_duration", + "Required": false + }, + { + "ROS": null, + "Terraform": "payment_duration_unit", + "Required": false + }, + { + "ROS": null, + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "reserve", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_endpoint_database_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_endpoint_engine_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_endpoint_instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_endpoint_instance_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_endpoint_ip", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_endpoint_oracle_sid", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_endpoint_owner_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_endpoint_password", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_endpoint_port", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_endpoint_region", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_endpoint_role", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_endpoint_user_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": null, + "Terraform": "subscription_data_type_ddl", + "Required": false + }, + { + "ROS": null, + "Terraform": "subscription_data_type_dml", + "Required": false + }, + { + "ROS": null, + "Terraform": "subscription_instance_network_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "subscription_instance_vpc_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "subscription_instance_vswitch_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "sync_architecture", + "Required": false + }, + { + "ROS": null, + "Terraform": "synchronization_direction", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_dts_synchronization_instance" + }, + "ProductCode": "dts", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "auto_pay", + "Required": false + }, + { + "ROS": null, + "Terraform": "auto_start", + "Required": false + }, + { + "ROS": null, + "Terraform": "compute_unit", + "Required": false + }, + { + "ROS": null, + "Terraform": "database_count", + "Required": false + }, + { + "ROS": null, + "Terraform": "destination_endpoint_engine_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "destination_endpoint_region", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_class", + "Required": false + }, + { + "ROS": null, + "Terraform": "payment_duration", + "Required": false + }, + { + "ROS": null, + "Terraform": "payment_duration_unit", + "Required": false + }, + { + "ROS": null, + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "quantity", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_endpoint_engine_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_endpoint_region", + "Required": false + }, + { + "ROS": null, + "Terraform": "sync_architecture", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_data_works_folder" + }, + "ProductCode": "dide", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "folder_path", + "Required": false + }, + { + "ROS": null, + "Terraform": "project_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ebs_dedicated_block_storage_cluster" + }, + "ProductCode": "disk", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "dedicated_block_storage_cluster_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "total_capacity", + "Required": false + }, + { + "ROS": null, + "Terraform": "type", + "Required": false + }, + { + "ROS": null, + "Terraform": "zone_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "available_capacity" + }, + { + "ROS": null, + "Terraform": "category" + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "dedicated_block_storage_cluster_id" + }, + { + "ROS": null, + "Terraform": "delivery_capacity" + }, + { + "ROS": null, + "Terraform": "description" + }, + { + "ROS": null, + "Terraform": "expired_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "performance_level" + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": null, + "Terraform": "supported_category" + }, + { + "ROS": null, + "Terraform": "used_capacity" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ebs_enterprise_snapshot_policy" + }, + "ProductCode": "disk", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "cross_region_copy_info", + "Required": false + }, + { + "ROS": null, + "Terraform": "desc", + "Required": false + }, + { + "ROS": null, + "Terraform": "enterprise_snapshot_policy_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "retain_rule", + "Required": false + }, + { + "ROS": null, + "Terraform": "schedule", + "Required": false + }, + { + "ROS": null, + "Terraform": "special_retain_rules", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": null, + "Terraform": "storage_rule", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": null, + "Terraform": "target_type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ebs_enterprise_snapshot_policy_attachment" + }, + "ProductCode": "disk", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "disk_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Disk" + } + ] + }, + { + "ROS": null, + "Terraform": "policy_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ebs_replica_group_drill" + }, + "ProductCode": "disk", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "group_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "replica_group_drill_id" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ebs_replica_pair_drill" + }, + "ProductCode": "disk", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "pair_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "replica_pair_drill_id" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ebs_solution_instance" + }, + "ProductCode": "disk", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "parameters", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "solution_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "solution_instance_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ecd_ad_connector_directory" + }, + "ProductCode": "ecd", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "desktop_access_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "directory_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "dns_address", + "Required": false + }, + { + "ROS": null, + "Terraform": "domain_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "domain_password", + "Required": false + }, + { + "ROS": null, + "Terraform": "domain_user_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "enable_admin_access", + "Required": false + }, + { + "ROS": null, + "Terraform": "mfa_enabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "specification", + "Required": false + }, + { + "ROS": null, + "Terraform": "sub_domain_dns_address", + "Required": false + }, + { + "ROS": null, + "Terraform": "sub_domain_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "vswitch_ids", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ecd_ad_connector_office_site" + }, + "ProductCode": "ecd", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "ad_connector_office_site_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "ad_hostname", + "Required": false + }, + { + "ROS": null, + "Terraform": "bandwidth", + "Required": false + }, + { + "ROS": null, + "Terraform": "cen_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "cen_owner_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "cidr_block", + "Required": false + }, + { + "ROS": null, + "Terraform": "desktop_access_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "dns_address", + "Required": false + }, + { + "ROS": null, + "Terraform": "domain_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "domain_password", + "Required": false + }, + { + "ROS": null, + "Terraform": "domain_user_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "enable_admin_access", + "Required": false + }, + { + "ROS": null, + "Terraform": "enable_internet_access", + "Required": false + }, + { + "ROS": null, + "Terraform": "mfa_enabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "protocol_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "specification", + "Required": false + }, + { + "ROS": null, + "Terraform": "sub_domain_dns_address", + "Required": false + }, + { + "ROS": null, + "Terraform": "sub_domain_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "verify_code", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ecd_command" + }, + "ProductCode": "ecd", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "command_content", + "Required": false + }, + { + "ROS": null, + "Terraform": "command_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "content_encoding", + "Required": false + }, + { + "ROS": null, + "Terraform": "desktop_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "timeout", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ecd_custom_property" + }, + "ProductCode": "ecd", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "property_key", + "Required": false + }, + { + "ROS": null, + "Terraform": "property_values", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ecd_image" + }, + "ProductCode": "ecd", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "desktop_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "image_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ecd_nas_file_system" + }, + "ProductCode": "ecd", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "file_system_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "mount_target_domain", + "Required": false + }, + { + "ROS": null, + "Terraform": "nas_file_system_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "office_site_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECD::SimpleOfficeSite" + } + ] + }, + { + "ROS": null, + "Terraform": "reset", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ecd_policy_group" + }, + "ProductCode": "ecd", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "authorize_access_policy_rules", + "Required": false + }, + { + "ROS": null, + "Terraform": "authorize_security_policy_rules", + "Required": false + }, + { + "ROS": null, + "Terraform": "camera_redirect", + "Required": false + }, + { + "ROS": null, + "Terraform": "clipboard", + "Required": false + }, + { + "ROS": null, + "Terraform": "domain_list", + "Required": false + }, + { + "ROS": null, + "Terraform": "html_access", + "Required": false + }, + { + "ROS": null, + "Terraform": "html_file_transfer", + "Required": false + }, + { + "ROS": null, + "Terraform": "local_drive", + "Required": false + }, + { + "ROS": null, + "Terraform": "policy_group_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "recording", + "Required": false + }, + { + "ROS": null, + "Terraform": "recording_end_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "recording_expires", + "Required": false + }, + { + "ROS": null, + "Terraform": "recording_fps", + "Required": false + }, + { + "ROS": null, + "Terraform": "recording_start_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "usb_redirect", + "Required": false + }, + { + "ROS": null, + "Terraform": "visual_quality", + "Required": false + }, + { + "ROS": null, + "Terraform": "watermark", + "Required": false + }, + { + "ROS": null, + "Terraform": "watermark_transparency", + "Required": false + }, + { + "ROS": null, + "Terraform": "watermark_type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ecd_ram_directory" + }, + "ProductCode": "ecd", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "desktop_access_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "enable_admin_access", + "Required": false + }, + { + "ROS": null, + "Terraform": "enable_internet_access", + "Required": false + }, + { + "ROS": null, + "Terraform": "ram_directory_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "vswitch_ids", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ecd_snapshot" + }, + "ProductCode": "ecd", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "desktop_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "snapshot_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_disk_type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ecd_user" + }, + "ProductCode": "ecd", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "email", + "Required": false + }, + { + "ROS": null, + "Terraform": "end_user_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "password", + "Required": false + }, + { + "ROS": null, + "Terraform": "phone", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_edas_application_deployment" + }, + "ProductCode": "edas", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "app_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "group_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "last_package_version", + "Required": false + }, + { + "ROS": null, + "Terraform": "package_version", + "Required": false + }, + { + "ROS": null, + "Terraform": "war_url", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_edas_application_scale" + }, + "ProductCode": "edas", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "app_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "deploy_group", + "Required": false + }, + { + "ROS": null, + "Terraform": "ecu_info", + "Required": false + }, + { + "ROS": null, + "Terraform": "force_status", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "ecc_info" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_edas_instance_cluster_attachment" + }, + "ProductCode": "edas", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "cluster_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_ids", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "cluster_member_ids" + }, + { + "ROS": null, + "Terraform": "ecu_map" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status_map" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_edas_slb_attachment" + }, + "ProductCode": "edas", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "app_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "listener_port", + "Required": false + }, + { + "ROS": null, + "Terraform": "slb_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "slb_ip", + "Required": false + }, + { + "ROS": null, + "Terraform": "type", + "Required": false + }, + { + "ROS": null, + "Terraform": "vserver_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::SLB::VServerGroup" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "slb_status" + }, + { + "ROS": null, + "Terraform": "vswitch_id", + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_eflo_subnet" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "cidr", + "Required": false + }, + { + "ROS": null, + "Terraform": "subnet_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "type", + "Required": false + }, + { + "ROS": null, + "Terraform": "vpd_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "zone_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "gmt_modified" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "message" + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": null, + "Terraform": "subnet_id" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_eflo_vpd" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "cidr", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "vpd_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "gmt_modified" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ehpc_job_template" + }, + "ProductCode": "ehpc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "array_request", + "Required": false + }, + { + "ROS": null, + "Terraform": "clock_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "command_line", + "Required": false + }, + { + "ROS": null, + "Terraform": "gpu", + "Required": false + }, + { + "ROS": null, + "Terraform": "job_template_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "mem", + "Required": false + }, + { + "ROS": null, + "Terraform": "node", + "Required": false + }, + { + "ROS": null, + "Terraform": "package_path", + "Required": false + }, + { + "ROS": null, + "Terraform": "priority", + "Required": false + }, + { + "ROS": null, + "Terraform": "queue", + "Required": false + }, + { + "ROS": null, + "Terraform": "re_runable", + "Required": false + }, + { + "ROS": null, + "Terraform": "runas_user", + "Required": false + }, + { + "ROS": null, + "Terraform": "stderr_redirect_path", + "Required": false + }, + { + "ROS": null, + "Terraform": "stdout_redirect_path", + "Required": false + }, + { + "ROS": null, + "Terraform": "task", + "Required": false + }, + { + "ROS": null, + "Terraform": "thread", + "Required": false + }, + { + "ROS": null, + "Terraform": "variables", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ens_eip" + }, + "ProductCode": "ens", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "bandwidth", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "eip_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "ens_region_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "internet_charge_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "isp", + "Required": false + }, + { + "ROS": null, + "Terraform": "payment_type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ens_eip_instance_attachment" + }, + "ProductCode": "ens", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "allocation_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "standby", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ens_load_balancer" + }, + "ProductCode": "ens", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "backend_servers", + "Required": false + }, + { + "ROS": null, + "Terraform": "ens_region_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "load_balancer_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "load_balancer_spec", + "Required": false + }, + { + "ROS": null, + "Terraform": "network_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ENS::Network" + } + ] + }, + { + "ROS": null, + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ens_nat_gateway" + }, + "ProductCode": "ens", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "ens_region_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "nat_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "network_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ENS::Network" + } + ] + }, + { + "ROS": null, + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ess_attachment" + }, + "ProductCode": "ess", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "Classic", + "Required": false + }, + { + "ROS": null, + "Terraform": "entrusted", + "Required": false + }, + { + "ROS": null, + "Terraform": "force", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_ids", + "Required": false + }, + { + "ROS": null, + "Terraform": "lifecycle_hook", + "Required": false + }, + { + "ROS": null, + "Terraform": "load_balancer_weights", + "Required": false + }, + { + "ROS": null, + "Terraform": "scaling_group_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ess_notification" + }, + "ProductCode": "ess", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "notification_arn", + "Required": false + }, + { + "ROS": null, + "Terraform": "notification_types", + "Required": false + }, + { + "ROS": null, + "Terraform": "scaling_group_id", + "Required": false + } + ], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ess_scalinggroup_vserver_groups" + }, + "ProductCode": "ess", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "force", + "Required": false + }, + { + "ROS": null, + "Terraform": "scaling_group_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "vserver_groups", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ess_schedule" + }, + "ProductCode": "ess", + "Name": { + "zh": null, + "en": null + }, + "Properties": [], + "Attributes": [] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ess_suspend_process" + }, + "ProductCode": "ess", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "process", + "Required": false + }, + { + "ROS": null, + "Terraform": "scaling_group_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_event_bridge_api_destination" + }, + "ProductCode": "eventbridge", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "api_destination_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "connection_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "http_api_parameters", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_event_bridge_connection" + }, + "ProductCode": "eventbridge", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "auth_parameters", + "Required": false + }, + { + "ROS": null, + "Terraform": "connection_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "network_parameters", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_event_bridge_event_bus" + }, + "ProductCode": "eventbridge", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "event_bus_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_event_bridge_event_source" + }, + "ProductCode": "eventbridge", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "event_bus_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "event_source_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "external_source_config", + "Required": false + }, + { + "ROS": null, + "Terraform": "external_source_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "linked_external_source", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_event_bridge_service_linked_role" + }, + "ProductCode": "eventbridge", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "product_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_fcv3_alias" + }, + "ProductCode": "fc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "additional_version_weight", + "Required": false + }, + { + "ROS": null, + "Terraform": "alias_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "function_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "version_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_fcv3_async_invoke_config" + }, + "ProductCode": "fc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "async_task", + "Required": false + }, + { + "ROS": null, + "Terraform": "destination_config", + "Required": false + }, + { + "ROS": null, + "Terraform": "function_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "max_async_event_age_in_seconds", + "Required": false + }, + { + "ROS": null, + "Terraform": "max_async_retry_attempts", + "Required": false + }, + { + "ROS": null, + "Terraform": "qualifier", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_fcv3_function_version" + }, + "ProductCode": "fc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "function_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_fcv3_layer_version" + }, + "ProductCode": "fc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "acl", + "Required": false + }, + { + "ROS": null, + "Terraform": "code", + "Required": false + }, + { + "ROS": null, + "Terraform": "compatible_runtime", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "layer_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "license", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "version" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_fcv3_vpc_binding" + }, + "ProductCode": "fc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "function_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_fc_function_async_invoke_config" + }, + "ProductCode": "fc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "destination_config", + "Required": false + }, + { + "ROS": null, + "Terraform": "function_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "maximum_event_age_in_seconds", + "Required": false + }, + { + "ROS": null, + "Terraform": "maximum_retry_attempts", + "Required": false + }, + { + "ROS": null, + "Terraform": "qualifier", + "Required": false + }, + { + "ROS": null, + "Terraform": "service_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "stateful_invocation", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "created_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "last_modified_time" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_fc_layer_version" + }, + "ProductCode": "fc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "compatible_runtime", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "layer_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "oss_bucket_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "oss_object_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "skip_destroy", + "Required": false + }, + { + "ROS": null, + "Terraform": "zip_file", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "acl" + }, + { + "ROS": null, + "Terraform": "arn" + }, + { + "ROS": null, + "Terraform": "code_check_sum" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "version" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_fnf_execution" + }, + "ProductCode": "fnf", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "execution_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "flow_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "input", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_realtime_compute_vvp_instance" + }, + "ProductCode": "sc", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "duration", + "Required": false + }, + { + "ROS": null, + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "pricing_cycle", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "resource_spec", + "Required": false + }, + { + "ROS": null, + "Terraform": "storage", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": null, + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": null, + "Terraform": "vswitch_ids", + "Required": false + }, + { + "ROS": null, + "Terraform": "vvp_instance_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "zone_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ga_accelerator_spare_ip_attachment" + }, + "ProductCode": "ga", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "accelerator_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GA::Accelerator" + } + ] + }, + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": null, + "Terraform": "spare_ip", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ga_access_log" + }, + "ProductCode": "ga", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "accelerator_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GA::Accelerator" + } + ] + }, + { + "ROS": null, + "Terraform": "endpoint_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GA::EndpointGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "listener_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "sls_log_store_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "sls_project_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "sls_region_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ga_acl_attachment" + }, + "ProductCode": "ga", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "acl_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "acl_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": null, + "Terraform": "listener_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ga_acl_entry_attachment" + }, + "ProductCode": "ga", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "acl_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "entry", + "Required": false + }, + { + "ROS": null, + "Terraform": "entry_description", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ga_additional_certificate" + }, + "ProductCode": "ga", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "accelerator_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GA::Accelerator" + } + ] + }, + { + "ROS": null, + "Terraform": "certificate_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "domain", + "Required": false + }, + { + "ROS": null, + "Terraform": "listener_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ga_basic_accelerate_ip_endpoint_relation" + }, + "ProductCode": "ga", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "accelerate_ip_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GA::BasicAccelerateIp" + } + ] + }, + { + "ROS": null, + "Terraform": "accelerator_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GA::Accelerator" + } + ] + }, + { + "ROS": null, + "Terraform": "endpoint_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ga_custom_routing_endpoint" + }, + "ProductCode": "ga", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "endpoint", + "Required": false + }, + { + "ROS": null, + "Terraform": "endpoint_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GA::EndpointGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "traffic_to_endpoint_policy", + "Required": false + }, + { + "ROS": null, + "Terraform": "type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "accelerator_id", + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GA::Accelerator" + } + ] + }, + { + "ROS": null, + "Terraform": "custom_routing_endpoint_id" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "listener_id" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ga_custom_routing_endpoint_group" + }, + "ProductCode": "ga", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "accelerator_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GA::Accelerator" + } + ] + }, + { + "ROS": null, + "Terraform": "custom_routing_endpoint_group_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "endpoint_group_region", + "Required": false + }, + { + "ROS": null, + "Terraform": "listener_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ga_custom_routing_endpoint_group_destination" + }, + "ProductCode": "ga", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "endpoint_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GA::EndpointGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "from_port", + "Required": false + }, + { + "ROS": null, + "Terraform": "protocols", + "Required": false + }, + { + "ROS": null, + "Terraform": "to_port", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "accelerator_id", + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GA::Accelerator" + } + ] + }, + { + "ROS": null, + "Terraform": "custom_routing_endpoint_group_destination_id" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "listener_id" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ga_custom_routing_endpoint_traffic_policy" + }, + "ProductCode": "ga", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "address", + "Required": false + }, + { + "ROS": null, + "Terraform": "endpoint_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "port_ranges", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "accelerator_id", + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GA::Accelerator" + } + ] + }, + { + "ROS": null, + "Terraform": "custom_routing_endpoint_traffic_policy_id" + }, + { + "ROS": null, + "Terraform": "endpoint_group_id", + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::GA::EndpointGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "listener_id" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_governance_account" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "account_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::Account" + } + ] + }, + { + "ROS": null, + "Terraform": "account_name_prefix", + "Required": false + }, + { + "ROS": null, + "Terraform": "baseline_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "default_domain_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "display_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "folder_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::Folder" + } + ] + }, + { + "ROS": null, + "Terraform": "payer_account_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_governance_baseline" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "baseline_items", + "Required": false + }, + { + "ROS": null, + "Terraform": "baseline_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_gpdb_backup_policy" + }, + "ProductCode": "gpdb", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "backup_retention_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "enable_recovery_point", + "Required": false + }, + { + "ROS": null, + "Terraform": "preferred_backup_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "preferred_backup_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "recovery_point_period", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_gpdb_connection" + }, + "ProductCode": "gpdb", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "connection_prefix", + "Required": false + }, + { + "ROS": null, + "Terraform": "connection_string", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "ip_address", + "Required": false + }, + { + "ROS": null, + "Terraform": "port", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_gpdb_database" + }, + "ProductCode": "gpdb", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "character_set_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "collate", + "Required": false + }, + { + "ROS": null, + "Terraform": "ctype", + "Required": false + }, + { + "ROS": null, + "Terraform": "database_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "owner", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_gpdb_db_instance_ip_array" + }, + "ProductCode": "gpdb", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "db_instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_instance_ip_array_attribute", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_instance_ip_array_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "modify_mode", + "Required": false + }, + { + "ROS": null, + "Terraform": "security_ip_list", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_gpdb_db_instance_plan" + }, + "ProductCode": "gpdb", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "db_instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_instance_plan_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "plan_config", + "Required": false + }, + { + "ROS": null, + "Terraform": "plan_desc", + "Required": false + }, + { + "ROS": null, + "Terraform": "plan_end_date", + "Required": false + }, + { + "ROS": null, + "Terraform": "plan_schedule_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "plan_start_date", + "Required": false + }, + { + "ROS": null, + "Terraform": "plan_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "plan_config" + }, + { + "ROS": null, + "Terraform": "plan_id", + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::HBR::DbPlan" + } + ] + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_gpdb_db_resource_group" + }, + "ProductCode": "gpdb", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "db_instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_config", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "role_list", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_gpdb_external_data_service" + }, + "ProductCode": "gpdb", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "db_instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "service_description", + "Required": false + }, + { + "ROS": null, + "Terraform": "service_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "service_spec", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "service_id" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_gpdb_hadoop_data_source" + }, + "ProductCode": "gpdb", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "data_source_description", + "Required": false + }, + { + "ROS": null, + "Terraform": "data_source_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "data_source_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "emr_instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "hadoop_core_conf", + "Required": false + }, + { + "ROS": null, + "Terraform": "hadoop_create_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "hadoop_hosts_address", + "Required": false + }, + { + "ROS": null, + "Terraform": "hdfs_conf", + "Required": false + }, + { + "ROS": null, + "Terraform": "hive_conf", + "Required": false + }, + { + "ROS": null, + "Terraform": "map_reduce_conf", + "Required": false + }, + { + "ROS": null, + "Terraform": "yarn_conf", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "data_source_id" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_gpdb_jdbc_data_source" + }, + "ProductCode": "gpdb", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "data_source_description", + "Required": false + }, + { + "ROS": null, + "Terraform": "data_source_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "data_source_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "jdbc_connection_string", + "Required": false + }, + { + "ROS": null, + "Terraform": "jdbc_password", + "Required": false + }, + { + "ROS": null, + "Terraform": "jdbc_user_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "data_source_id" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_gpdb_remote_adb_data_source" + }, + "ProductCode": "gpdb", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "data_source_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "local_database", + "Required": false + }, + { + "ROS": null, + "Terraform": "local_db_instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "manager_user_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "manager_user_password", + "Required": false + }, + { + "ROS": null, + "Terraform": "remote_database", + "Required": false + }, + { + "ROS": null, + "Terraform": "remote_db_instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "user_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "user_password", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "remote_adb_data_source_id" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_gpdb_streaming_data_service" + }, + "ProductCode": "gpdb", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "db_instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "service_description", + "Required": false + }, + { + "ROS": null, + "Terraform": "service_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "service_spec", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "service_id" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_gpdb_streaming_data_source" + }, + "ProductCode": "gpdb", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "data_source_config", + "Required": false + }, + { + "ROS": null, + "Terraform": "data_source_description", + "Required": false + }, + { + "ROS": null, + "Terraform": "data_source_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "data_source_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "service_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "data_source_id" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_gpdb_streaming_job" + }, + "ProductCode": "gpdb", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "account", + "Required": false + }, + { + "ROS": null, + "Terraform": "consistency", + "Required": false + }, + { + "ROS": null, + "Terraform": "data_source_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "dest_columns", + "Required": false + }, + { + "ROS": null, + "Terraform": "dest_database", + "Required": false + }, + { + "ROS": null, + "Terraform": "dest_schema", + "Required": false + }, + { + "ROS": null, + "Terraform": "dest_table", + "Required": false + }, + { + "ROS": null, + "Terraform": "error_limit_count", + "Required": false + }, + { + "ROS": null, + "Terraform": "fallback_offset", + "Required": false + }, + { + "ROS": null, + "Terraform": "group_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "job_config", + "Required": false + }, + { + "ROS": null, + "Terraform": "job_description", + "Required": false + }, + { + "ROS": null, + "Terraform": "job_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "match_columns", + "Required": false + }, + { + "ROS": null, + "Terraform": "mode", + "Required": false + }, + { + "ROS": null, + "Terraform": "password", + "Required": false + }, + { + "ROS": null, + "Terraform": "src_columns", + "Required": false + }, + { + "ROS": null, + "Terraform": "try_run", + "Required": false + }, + { + "ROS": null, + "Terraform": "update_columns", + "Required": false + }, + { + "ROS": null, + "Terraform": "write_mode", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "job_id" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_hbr_ecs_backup_plan" + }, + "ProductCode": "hbr", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "backup_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "cross_account_role_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "cross_account_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "cross_account_user_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "detail", + "Required": false + }, + { + "ROS": null, + "Terraform": "disabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "ecs_backup_plan_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "exclude", + "Required": false + }, + { + "ROS": null, + "Terraform": "include", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "options", + "Required": false + }, + { + "ROS": null, + "Terraform": "path", + "Required": false + }, + { + "ROS": null, + "Terraform": "retention", + "Required": false + }, + { + "ROS": null, + "Terraform": "schedule", + "Required": false + }, + { + "ROS": null, + "Terraform": "speed_limit", + "Required": false + }, + { + "ROS": null, + "Terraform": "vault_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_hbr_hana_backup_client" + }, + "ProductCode": "hbr", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "alert_setting", + "Required": false + }, + { + "ROS": null, + "Terraform": "client_info", + "Required": false + }, + { + "ROS": null, + "Terraform": "use_https", + "Required": false + }, + { + "ROS": null, + "Terraform": "vault_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "client_id" + }, + { + "ROS": null, + "Terraform": "cluster_id" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "instance_id" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_hbr_hana_backup_plan" + }, + "ProductCode": "hbr", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "backup_prefix", + "Required": false + }, + { + "ROS": null, + "Terraform": "backup_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "cluster_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "database_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "plan_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "schedule", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": null, + "Terraform": "vault_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "plan_id", + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::HBR::DbPlan" + } + ] + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_hbr_hana_instance" + }, + "ProductCode": "hbr", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "alert_setting", + "Required": false + }, + { + "ROS": null, + "Terraform": "ecs_instance_ids", + "Required": false + }, + { + "ROS": null, + "Terraform": "hana_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "host", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_number", + "Required": false + }, + { + "ROS": null, + "Terraform": "password", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "sid", + "Required": false + }, + { + "ROS": null, + "Terraform": "user_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "use_ssl", + "Required": false + }, + { + "ROS": null, + "Terraform": "validate_certificate", + "Required": false + }, + { + "ROS": null, + "Terraform": "vault_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "hana_instance_id" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_hbr_nas_backup_plan" + }, + "ProductCode": "hbr", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "backup_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "cross_account_role_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "cross_account_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "cross_account_user_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "disabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "file_system_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "nas_backup_plan_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "options", + "Required": false + }, + { + "ROS": null, + "Terraform": "path", + "Required": false + }, + { + "ROS": null, + "Terraform": "retention", + "Required": false + }, + { + "ROS": null, + "Terraform": "schedule", + "Required": false + }, + { + "ROS": null, + "Terraform": "vault_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_hbr_oss_backup_plan" + }, + "ProductCode": "hbr", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "backup_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "bucket", + "Required": false + }, + { + "ROS": null, + "Terraform": "cross_account_role_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "cross_account_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "cross_account_user_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "disabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "oss_backup_plan_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "prefix", + "Required": false + }, + { + "ROS": null, + "Terraform": "retention", + "Required": false + }, + { + "ROS": null, + "Terraform": "schedule", + "Required": false + }, + { + "ROS": null, + "Terraform": "vault_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_hbr_ots_backup_plan" + }, + "ProductCode": "hbr", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "backup_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "cross_account_role_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "cross_account_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "cross_account_user_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "disabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "ots_backup_plan_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "ots_detail", + "Required": false + }, + { + "ROS": null, + "Terraform": "retention", + "Required": false + }, + { + "ROS": null, + "Terraform": "rules", + "Required": false + }, + { + "ROS": null, + "Terraform": "vault_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_hbr_policy" + }, + "ProductCode": "hbr", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "policy_description", + "Required": false + }, + { + "ROS": null, + "Terraform": "policy_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "rules", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "rules" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_hbr_policy_binding" + }, + "ProductCode": "hbr", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "advanced_options", + "Required": false + }, + { + "ROS": null, + "Terraform": "cross_account_role_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "cross_account_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "cross_account_user_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "data_source_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "disabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "exclude", + "Required": false + }, + { + "ROS": null, + "Terraform": "include", + "Required": false + }, + { + "ROS": null, + "Terraform": "policy_binding_description", + "Required": false + }, + { + "ROS": null, + "Terraform": "policy_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "source", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "speed_limit", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_hbr_replication_vault" + }, + "ProductCode": "hbr", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "replication_source_region_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "replication_source_vault_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "vault_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "vault_storage_class", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_hbr_server_backup_plan" + }, + "ProductCode": "hbr", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "app_consistent", + "Required": false + }, + { + "ROS": null, + "Terraform": "cross_account_role_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "cross_account_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "cross_account_user_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "destination_region_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "destination_retention", + "Required": false + }, + { + "ROS": null, + "Terraform": "detail", + "Required": false + }, + { + "ROS": null, + "Terraform": "disabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "disk_id_list", + "Required": false + }, + { + "ROS": null, + "Terraform": "do_copy", + "Required": false + }, + { + "ROS": null, + "Terraform": "ecs_server_backup_plan_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "enable_fs_freeze", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "post_script_path", + "Required": false + }, + { + "ROS": null, + "Terraform": "pre_script_path", + "Required": false + }, + { + "ROS": null, + "Terraform": "retention", + "Required": false + }, + { + "ROS": null, + "Terraform": "schedule", + "Required": false + }, + { + "ROS": null, + "Terraform": "snapshot_group", + "Required": false + }, + { + "ROS": null, + "Terraform": "timeout_in_seconds", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_image_export" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "image_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::CustomImage" + } + ] + }, + { + "ROS": null, + "Terraform": "oss_bucket", + "Required": false + }, + { + "ROS": null, + "Terraform": "oss_prefix", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_image_import" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "architecture", + "Required": false + }, + { + "ROS": null, + "Terraform": "boot_mode", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "disk_device_mapping", + "Required": false + }, + { + "ROS": null, + "Terraform": "image_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "license_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "os_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "platform", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_imp_app_template" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "app_template_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "component_list", + "Required": false + }, + { + "ROS": null, + "Terraform": "config_list", + "Required": false + }, + { + "ROS": null, + "Terraform": "integration_mode", + "Required": false + }, + { + "ROS": null, + "Terraform": "key", + "Required": false + }, + { + "ROS": null, + "Terraform": "scene", + "Required": false + }, + { + "ROS": null, + "Terraform": "value", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ims_oidc_provider" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "client_ids", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "fingerprints", + "Required": false + }, + { + "ROS": null, + "Terraform": "issuance_limit_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "issuer_url", + "Required": false + }, + { + "ROS": null, + "Terraform": "oidc_provider_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_alikafka_instance_allowed_ip_attachment" + }, + "ProductCode": "alikafka", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "allowed_ip", + "Required": false + }, + { + "ROS": null, + "Terraform": "allowed_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "port_range", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_alikafka_sasl_acl" + }, + "ProductCode": "alikafka", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "acl_operation_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "acl_resource_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "acl_resource_pattern_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "acl_resource_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "username", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "host" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_kms_application_access_point" + }, + "ProductCode": "kms", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "application_access_point_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "policies", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_kms_ciphertext" + }, + "ProductCode": "kms", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "encryption_context", + "Required": false + }, + { + "ROS": null, + "Terraform": "key_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::KMS::Key" + } + ] + }, + { + "ROS": null, + "Terraform": "plaintext", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "ciphertext_blob" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_kms_client_key" + }, + "ProductCode": "kms", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "aap_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "not_after", + "Required": false + }, + { + "ROS": null, + "Terraform": "not_before", + "Required": false + }, + { + "ROS": null, + "Terraform": "password", + "Required": false + }, + { + "ROS": null, + "Terraform": "private_key_data_file", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_kms_key_version" + }, + "ProductCode": "kms", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "key_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::KMS::Key" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "creation_date" + }, + { + "ROS": null, + "Terraform": "key_id", + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::KMS::Key" + } + ] + }, + { + "ROS": null, + "Terraform": "key_version_id" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_logtail_attachment" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "logtail_config_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "machine_group_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "project", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_mhub_app" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "app_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "bundle_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECD::Bundle" + } + ] + }, + { + "ROS": null, + "Terraform": "encoded_icon", + "Required": false + }, + { + "ROS": null, + "Terraform": "industry_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "package_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "product_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_mhub_product" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "product_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_mongodb_account" + }, + "ProductCode": "mongodb", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "account_description", + "Required": false + }, + { + "ROS": null, + "Terraform": "account_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "account_password", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_mongodb_audit_policy" + }, + "ProductCode": "mongodb", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "audit_status", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "storage_period", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_mongodb_serverless_instance" + }, + "ProductCode": "mongodb", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "account_password", + "Required": false + }, + { + "ROS": null, + "Terraform": "auto_renew", + "Required": false + }, + { + "ROS": null, + "Terraform": "capacity_unit", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_instance_description", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_instance_storage", + "Required": false + }, + { + "ROS": null, + "Terraform": "engine", + "Required": false + }, + { + "ROS": null, + "Terraform": "engine_version", + "Required": false + }, + { + "ROS": null, + "Terraform": "maintain_end_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "maintain_start_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "period", + "Required": false + }, + { + "ROS": null, + "Terraform": "period_price_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "security_ip_group_attribute", + "Required": false + }, + { + "ROS": null, + "Terraform": "security_ip_group_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "security_ip_groups", + "Required": false + }, + { + "ROS": null, + "Terraform": "security_ip_list", + "Required": false + }, + { + "ROS": null, + "Terraform": "storage_engine", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": null, + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": null, + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": null, + "Terraform": "zone_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_mongodb_sharding_network_private_address" + }, + "ProductCode": "mongodb", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "account_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "account_password", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "node_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "zone_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "network_address" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_mongodb_sharding_network_public_address" + }, + "ProductCode": "mongodb", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "db_instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "node_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "network_address" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_msc_sub_contact" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "contact_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "email", + "Required": false + }, + { + "ROS": null, + "Terraform": "mobile", + "Required": false + }, + { + "ROS": null, + "Terraform": "position", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_msc_sub_subscription" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "contact_ids", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ARMS::AlertContact" + } + ] + }, + { + "ROS": null, + "Terraform": "email_status", + "Required": false + }, + { + "ROS": null, + "Terraform": "item_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "pmsg_status", + "Required": false + }, + { + "ROS": null, + "Terraform": "sms_status", + "Required": false + }, + { + "ROS": null, + "Terraform": "tts_status", + "Required": false + }, + { + "ROS": null, + "Terraform": "webhook_ids", + "Required": false + }, + { + "ROS": null, + "Terraform": "webhook_status", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "channel" + }, + { + "ROS": null, + "Terraform": "description" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_msc_sub_webhook" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "server_url", + "Required": false + }, + { + "ROS": null, + "Terraform": "webhook_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_mse_znode" + }, + "ProductCode": "mse", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "accept_language", + "Required": false + }, + { + "ROS": null, + "Terraform": "cluster_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "data", + "Required": false + }, + { + "ROS": null, + "Terraform": "path", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_network_acl_entries" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "egress", + "Required": false + }, + { + "ROS": null, + "Terraform": "ingress", + "Required": false + }, + { + "ROS": null, + "Terraform": "network_acl_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_nlb_listener_additional_certificate_attachment" + }, + "ProductCode": "nlb", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "certificate_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": null, + "Terraform": "listener_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_nlb_loadbalancer_common_bandwidth_package_attachment" + }, + "ProductCode": "nlb", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "bandwidth_package_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "load_balancer_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ots_instance_attachment" + }, + "ProductCode": "ots", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "instance_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "vpc_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "vpc_id", + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ots_secondary_index" + }, + "ProductCode": "ots", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "defined_columns", + "Required": false + }, + { + "ROS": null, + "Terraform": "include_base_data", + "Required": false + }, + { + "ROS": null, + "Terraform": "index_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "index_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "primary_keys", + "Required": false + }, + { + "ROS": null, + "Terraform": "table_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ots_tunnel" + }, + "ProductCode": "ots", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "instance_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "table_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "tunnel_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "tunnel_type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "channels" + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "expired" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "tunnel_id" + }, + { + "ROS": null, + "Terraform": "tunnel_rpo" + }, + { + "ROS": null, + "Terraform": "tunnel_stage" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_ocean_base_instance" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "auto_renew", + "Required": false + }, + { + "ROS": null, + "Terraform": "auto_renew_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "backup_retain_mode", + "Required": false + }, + { + "ROS": null, + "Terraform": "cpu", + "Required": false + }, + { + "ROS": null, + "Terraform": "cpu_arch", + "Required": false + }, + { + "ROS": null, + "Terraform": "disk_size", + "Required": false + }, + { + "ROS": null, + "Terraform": "disk_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_class", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "node_num", + "Required": false + }, + { + "ROS": null, + "Terraform": "ob_version", + "Required": false + }, + { + "ROS": null, + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "period", + "Required": false + }, + { + "ROS": null, + "Terraform": "period_unit", + "Required": false + }, + { + "ROS": null, + "Terraform": "primary_instance", + "Required": false + }, + { + "ROS": null, + "Terraform": "primary_region", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "series", + "Required": false + }, + { + "ROS": null, + "Terraform": "upgrade_spec_native", + "Required": false + }, + { + "ROS": null, + "Terraform": "zones", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "commodity_code" + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_open_search_app_group" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "app_group_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "auto_renew", + "Required": false + }, + { + "ROS": null, + "Terraform": "charge_way", + "Required": false + }, + { + "ROS": null, + "Terraform": "compute_resource", + "Required": false + }, + { + "ROS": null, + "Terraform": "current_version", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "doc_size", + "Required": false + }, + { + "ROS": null, + "Terraform": "duration", + "Required": false + }, + { + "ROS": null, + "Terraform": "order", + "Required": false + }, + { + "ROS": null, + "Terraform": "order_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "pricing_cycle", + "Required": false + }, + { + "ROS": null, + "Terraform": "qps", + "Required": false + }, + { + "ROS": null, + "Terraform": "quota", + "Required": false + }, + { + "ROS": null, + "Terraform": "spec", + "Required": false + }, + { + "ROS": null, + "Terraform": "type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "instance_id" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_polardb_backup_policy" + }, + "ProductCode": "polardb", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "backup_frequency", + "Required": false + }, + { + "ROS": null, + "Terraform": "backup_retention_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "backup_retention_policy_on_cluster_deletion", + "Required": false + }, + { + "ROS": null, + "Terraform": "data_level1_backup_frequency", + "Required": false + }, + { + "ROS": null, + "Terraform": "data_level1_backup_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "data_level1_backup_retention_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "data_level1_backup_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "data_level2_backup_another_region_region", + "Required": false + }, + { + "ROS": null, + "Terraform": "data_level2_backup_another_region_retention_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "data_level2_backup_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "data_level2_backup_retention_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_cluster_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "log_backup_another_region_region", + "Required": false + }, + { + "ROS": null, + "Terraform": "log_backup_another_region_retention_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "log_backup_retention_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "preferred_backup_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "preferred_backup_time", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "enable_backup_log" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_polardb_cluster_endpoint" + }, + "ProductCode": "polardb", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "auto_add_new_nodes", + "Required": false + }, + { + "ROS": null, + "Terraform": "connection_prefix", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_cluster_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_endpoint_description", + "Required": false + }, + { + "ROS": null, + "Terraform": "endpoint_config", + "Required": false + }, + { + "ROS": null, + "Terraform": "net_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "nodes", + "Required": false + }, + { + "ROS": null, + "Terraform": "port", + "Required": false + }, + { + "ROS": null, + "Terraform": "read_write_mode", + "Required": false + }, + { + "ROS": null, + "Terraform": "ssl_auto_rotate", + "Required": false + }, + { + "ROS": null, + "Terraform": "ssl_enabled", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "db_endpoint_id" + }, + { + "ROS": null, + "Terraform": "endpoint_type" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "ssl_certificate_url" + }, + { + "ROS": null, + "Terraform": "ssl_connection_string" + }, + { + "ROS": null, + "Terraform": "ssl_expire_time" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_polardb_primary_endpoint" + }, + "ProductCode": "polardb", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "connection_prefix", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_cluster_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_endpoint_description", + "Required": false + }, + { + "ROS": null, + "Terraform": "net_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "port", + "Required": false + }, + { + "ROS": null, + "Terraform": "ssl_auto_rotate", + "Required": false + }, + { + "ROS": null, + "Terraform": "ssl_enabled", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "db_endpoint_id" + }, + { + "ROS": null, + "Terraform": "endpoint_type" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "ssl_certificate_url" + }, + { + "ROS": null, + "Terraform": "ssl_connection_string" + }, + { + "ROS": null, + "Terraform": "ssl_expire_time" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_pvtz_endpoint" + }, + "ProductCode": "pvtz", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "endpoint_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "ip_configs", + "Required": false + }, + { + "ROS": null, + "Terraform": "security_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::SecurityGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": null, + "Terraform": "vpc_region_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_pvtz_rule_attachment" + }, + "ProductCode": "pvtz", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "rule_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "vpcs", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_pvtz_zone_attachment" + }, + "ProductCode": "pvtz", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "lang", + "Required": false + }, + { + "ROS": null, + "Terraform": "user_client_ip", + "Required": false + }, + { + "ROS": null, + "Terraform": "vpc_ids", + "Required": false + }, + { + "ROS": null, + "Terraform": "vpcs", + "Required": false + }, + { + "ROS": null, + "Terraform": "zone_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_privatelink_vpc_endpoint_connection" + }, + "ProductCode": "privatelink", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "bandwidth", + "Required": false + }, + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": null, + "Terraform": "endpoint_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "service_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_privatelink_vpc_endpoint_service_resource" + }, + "ProductCode": "privatelink", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "service_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "zone_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_privatelink_vpc_endpoint_service_user" + }, + "ProductCode": "privatelink", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": null, + "Terraform": "service_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "user_arn", + "Required": false + }, + { + "ROS": null, + "Terraform": "user_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_privatelink_vpc_endpoint_zone" + }, + "ProductCode": "privatelink", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "dry_run", + "Required": false + }, + { + "ROS": null, + "Terraform": "endpoint_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "eni_ip", + "Required": false + }, + { + "ROS": null, + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": null, + "Terraform": "zone_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_quick_bi_user" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "account_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::Account" + } + ] + }, + { + "ROS": null, + "Terraform": "account_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "admin_user", + "Required": false + }, + { + "ROS": null, + "Terraform": "auth_admin_user", + "Required": false + }, + { + "ROS": null, + "Terraform": "nick_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "user_type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_quotas_quota_alarm" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "product_code", + "Required": false + }, + { + "ROS": null, + "Terraform": "quota_action_code", + "Required": false + }, + { + "ROS": null, + "Terraform": "quota_alarm_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "quota_dimensions", + "Required": false + }, + { + "ROS": null, + "Terraform": "threshold", + "Required": false + }, + { + "ROS": null, + "Terraform": "threshold_percent", + "Required": false + }, + { + "ROS": null, + "Terraform": "threshold_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "web_hook", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_quotas_quota_application" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "audit_mode", + "Required": false + }, + { + "ROS": null, + "Terraform": "desire_value", + "Required": false + }, + { + "ROS": null, + "Terraform": "dimensions", + "Required": false + }, + { + "ROS": null, + "Terraform": "effective_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "env_language", + "Required": false + }, + { + "ROS": null, + "Terraform": "expire_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "notice_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "product_code", + "Required": false + }, + { + "ROS": null, + "Terraform": "quota_action_code", + "Required": false + }, + { + "ROS": null, + "Terraform": "quota_category", + "Required": false + }, + { + "ROS": null, + "Terraform": "reason", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "approve_value" + }, + { + "ROS": null, + "Terraform": "audit_reason" + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "quota_description" + }, + { + "ROS": null, + "Terraform": "quota_name" + }, + { + "ROS": null, + "Terraform": "quota_unit" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_quotas_template_applications" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "aliyun_uids", + "Required": false + }, + { + "ROS": null, + "Terraform": "desire_value", + "Required": false + }, + { + "ROS": null, + "Terraform": "dimensions", + "Required": false + }, + { + "ROS": null, + "Terraform": "effective_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "env_language", + "Required": false + }, + { + "ROS": null, + "Terraform": "expire_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "notice_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "product_code", + "Required": false + }, + { + "ROS": null, + "Terraform": "quota_action_code", + "Required": false + }, + { + "ROS": null, + "Terraform": "quota_category", + "Required": false + }, + { + "ROS": null, + "Terraform": "reason", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "quota_application_details" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_quotas_template_quota" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "desire_value", + "Required": false + }, + { + "ROS": null, + "Terraform": "dimensions", + "Required": false + }, + { + "ROS": null, + "Terraform": "effective_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "env_language", + "Required": false + }, + { + "ROS": null, + "Terraform": "expire_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "notice_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "product_code", + "Required": false + }, + { + "ROS": null, + "Terraform": "quota_action_code", + "Required": false + }, + { + "ROS": null, + "Terraform": "quota_category", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_quotas_template_service" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "service_status", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_rdc_organization" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "desired_member_count", + "Required": false + }, + { + "ROS": null, + "Terraform": "organization_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "real_pk", + "Required": false + }, + { + "ROS": null, + "Terraform": "source", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_reserved_instance" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "auto_renew_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_amount", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "offering_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "period", + "Required": false + }, + { + "ROS": null, + "Terraform": "period_unit", + "Required": false + }, + { + "ROS": null, + "Terraform": "platform", + "Required": false + }, + { + "ROS": null, + "Terraform": "renewal_status", + "Required": false + }, + { + "ROS": null, + "Terraform": "reserved_instance_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "scope", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": null, + "Terraform": "zone_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "allocation_status" + }, + { + "ROS": null, + "Terraform": "create" + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "expired_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "operation_locks" + }, + { + "ROS": null, + "Terraform": "start_time" + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": null, + "Terraform": "update" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_resource_manager_delegated_administrator" + }, + "ProductCode": "entconsole", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "account_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::Account" + } + ] + }, + { + "ROS": null, + "Terraform": "service_principal", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_resource_manager_policy" + }, + "ProductCode": "entconsole", + "Name": { + "zh": "ResourceManager策略", + "en": "Resource Management Policy" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "policy_document", + "Required": false + }, + { + "ROS": null, + "Terraform": "policy_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "policy_type" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_resource_manager_policy_version" + }, + "ProductCode": "entconsole", + "Name": { + "zh": "ResourceManager策略版本", + "en": "Resource Management Policy Version" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "create_date", + "Required": false + }, + { + "ROS": null, + "Terraform": "policy_document", + "Required": false + }, + { + "ROS": null, + "Terraform": "policy_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "version_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_resource_manager_role" + }, + "ProductCode": "entconsole", + "Name": { + "zh": "ResourceManager角色", + "en": "Resource Management Role" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "assume_role_policy_document", + "Required": false + }, + { + "ROS": null, + "Terraform": "create_date", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "max_session_duration", + "Required": false + }, + { + "ROS": null, + "Terraform": "role_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "arn" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "role_id" + }, + { + "ROS": null, + "Terraform": "update_date" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_resource_manager_saved_query" + }, + "ProductCode": "entconsole", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "expression", + "Required": false + }, + { + "ROS": null, + "Terraform": "saved_query_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_resource_manager_service_linked_role" + }, + "ProductCode": "entconsole", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "custom_suffix", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "service_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "arn" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "role_id" + }, + { + "ROS": null, + "Terraform": "role_name" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_resource_manager_shared_resource" + }, + "ProductCode": "entconsole", + "Name": { + "zh": "ResourceManager SharedResource", + "en": "Resource Management Shared Resource" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "resource_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_share_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceShare" + } + ] + }, + { + "ROS": null, + "Terraform": "resource_type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_resource_manager_shared_target" + }, + "ProductCode": "entconsole", + "Name": { + "zh": "资源管理共享单元", + "en": "Resource Management Shared Target" + }, + "Properties": [ + { + "ROS": null, + "Terraform": "resource_share_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceShare" + } + ] + }, + { + "ROS": null, + "Terraform": "target_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_sae_grey_tag_route" + }, + "ProductCode": "sae", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "app_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "dubbo_rules", + "Required": false + }, + { + "ROS": null, + "Terraform": "grey_tag_route_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "sc_rules", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_sae_load_balancer_internet" + }, + "ProductCode": "sae", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "app_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "internet", + "Required": false + }, + { + "ROS": null, + "Terraform": "internet_slb_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "internet_ip" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_sae_load_balancer_intranet" + }, + "ProductCode": "sae", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "app_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "intranet", + "Required": false + }, + { + "ROS": null, + "Terraform": "intranet_slb_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "intranet_ip" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_sag_client_user" + }, + "ProductCode": "smartag", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "bandwidth", + "Required": false + }, + { + "ROS": null, + "Terraform": "client_ip", + "Required": false + }, + { + "ROS": null, + "Terraform": "kms_encrypted_password", + "Required": false + }, + { + "ROS": null, + "Terraform": "kms_encryption_context", + "Required": false + }, + { + "ROS": null, + "Terraform": "password", + "Required": false + }, + { + "ROS": null, + "Terraform": "sag_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "user_mail", + "Required": false + }, + { + "ROS": null, + "Terraform": "user_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_sag_dnat_entry" + }, + "ProductCode": "smartag", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "external_ip", + "Required": false + }, + { + "ROS": null, + "Terraform": "external_port", + "Required": false + }, + { + "ROS": null, + "Terraform": "internal_ip", + "Required": false + }, + { + "ROS": null, + "Terraform": "internal_port", + "Required": false + }, + { + "ROS": null, + "Terraform": "ip_protocol", + "Required": false + }, + { + "ROS": null, + "Terraform": "sag_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_smartag_flow_log" + }, + "ProductCode": "smartag", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "active_aging", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "flow_log_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "inactive_aging", + "Required": false + }, + { + "ROS": null, + "Terraform": "logstore_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "netflow_server_ip", + "Required": false + }, + { + "ROS": null, + "Terraform": "netflow_server_port", + "Required": false + }, + { + "ROS": null, + "Terraform": "netflow_version", + "Required": false + }, + { + "ROS": null, + "Terraform": "output_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "project_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "sls_region_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_sag_snat_entry" + }, + "ProductCode": "smartag", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "cidr_block", + "Required": false + }, + { + "ROS": null, + "Terraform": "sag_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "snat_ip", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_simple_application_server_custom_image" + }, + "ProductCode": "sas", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "custom_image_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": null, + "Terraform": "system_snapshot_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_simple_application_server_firewall_rule" + }, + "ProductCode": "sas", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "port", + "Required": false + }, + { + "ROS": null, + "Terraform": "remark", + "Required": false + }, + { + "ROS": null, + "Terraform": "rule_protocol", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "firewall_rule_id" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_simple_application_server_snapshot" + }, + "ProductCode": "sas", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "disk_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::Disk" + } + ] + }, + { + "ROS": null, + "Terraform": "snapshot_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_scdn_domain" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "arg_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "arg_value", + "Required": false + }, + { + "ROS": null, + "Terraform": "cert_infos", + "Required": false + }, + { + "ROS": null, + "Terraform": "cert_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "cert_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "check_url", + "Required": false + }, + { + "ROS": null, + "Terraform": "content", + "Required": false + }, + { + "ROS": null, + "Terraform": "domain_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "enabled", + "Required": false + }, + { + "ROS": null, + "Terraform": "force_set", + "Required": false + }, + { + "ROS": null, + "Terraform": "port", + "Required": false + }, + { + "ROS": null, + "Terraform": "priority", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "sources", + "Required": false + }, + { + "ROS": null, + "Terraform": "ssl_pri", + "Required": false + }, + { + "ROS": null, + "Terraform": "ssl_protocol", + "Required": false + }, + { + "ROS": null, + "Terraform": "ssl_pub", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": null, + "Terraform": "type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_scdn_domain_config" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "domain_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "function_args", + "Required": false + }, + { + "ROS": null, + "Terraform": "function_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "config_id" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_schedulerx_namespace" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "namespace_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_sddp_config" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "code", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "lang", + "Required": false + }, + { + "ROS": null, + "Terraform": "value", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_sddp_data_limit" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "audit_status", + "Required": false + }, + { + "ROS": null, + "Terraform": "engine_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "lang", + "Required": false + }, + { + "ROS": null, + "Terraform": "log_store_day", + "Required": false + }, + { + "ROS": null, + "Terraform": "parent_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "password", + "Required": false + }, + { + "ROS": null, + "Terraform": "port", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "service_region_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "user_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_sddp_instance" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "dataphin", + "Required": false + }, + { + "ROS": null, + "Terraform": "dataphin_count", + "Required": false + }, + { + "ROS": null, + "Terraform": "logistics", + "Required": false + }, + { + "ROS": null, + "Terraform": "modify_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "oss_size", + "Required": false + }, + { + "ROS": null, + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "period", + "Required": false + }, + { + "ROS": null, + "Terraform": "renewal_status", + "Required": false + }, + { + "ROS": null, + "Terraform": "renew_period", + "Required": false + }, + { + "ROS": null, + "Terraform": "sdc", + "Required": false + }, + { + "ROS": null, + "Terraform": "sd_cbool", + "Required": false + }, + { + "ROS": null, + "Terraform": "sddp_version", + "Required": false + }, + { + "ROS": null, + "Terraform": "udc", + "Required": false + }, + { + "ROS": null, + "Terraform": "ud_cbool", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "authed" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "instance_num" + }, + { + "ROS": null, + "Terraform": "odps_set" + }, + { + "ROS": null, + "Terraform": "oss_bucket_set" + }, + { + "ROS": null, + "Terraform": "rds_set" + }, + { + "ROS": null, + "Terraform": "remain_days" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_sddp_rule" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "category", + "Required": false + }, + { + "ROS": null, + "Terraform": "content", + "Required": false + }, + { + "ROS": null, + "Terraform": "content_category", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "lang", + "Required": false + }, + { + "ROS": null, + "Terraform": "product_code", + "Required": false + }, + { + "ROS": null, + "Terraform": "product_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "risk_level_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "rule_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "rule_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "stat_express", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": null, + "Terraform": "target", + "Required": false + }, + { + "ROS": null, + "Terraform": "warn_level", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "custom_type" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_security_center_group" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "group_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "group_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_security_center_service_linked_role" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_selectdb_db_cluster" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "cache_size", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_cluster_class", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_cluster_description", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_instance_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "desired_params", + "Required": false + }, + { + "ROS": null, + "Terraform": "desired_status", + "Required": false + }, + { + "ROS": null, + "Terraform": "payment_type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "cache_size" + }, + { + "ROS": null, + "Terraform": "cpu" + }, + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "db_cluster_id" + }, + { + "ROS": null, + "Terraform": "engine" + }, + { + "ROS": null, + "Terraform": "engine_version" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "memory" + }, + { + "ROS": null, + "Terraform": "param_change_logs" + }, + { + "ROS": null, + "Terraform": "region_id" + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": null, + "Terraform": "vpc_id", + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": null, + "Terraform": "zone_id" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_selectdb_db_instance" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "cache_size", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_instance_class", + "Required": false + }, + { + "ROS": null, + "Terraform": "db_instance_description", + "Required": false + }, + { + "ROS": null, + "Terraform": "desired_security_ip_lists", + "Required": false + }, + { + "ROS": null, + "Terraform": "enable_public_network", + "Required": false + }, + { + "ROS": null, + "Terraform": "payment_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "period", + "Required": false + }, + { + "ROS": null, + "Terraform": "period_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": null, + "Terraform": "upgraded_engine_minor_version", + "Required": false + }, + { + "ROS": null, + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + }, + { + "ROS": null, + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + }, + { + "ROS": null, + "Terraform": "zone_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "cache_size_postpaid" + }, + { + "ROS": null, + "Terraform": "cache_size_prepaid" + }, + { + "ROS": null, + "Terraform": "cluster_count_postpaid" + }, + { + "ROS": null, + "Terraform": "cluster_count_prepaid" + }, + { + "ROS": null, + "Terraform": "cpu_postpaid" + }, + { + "ROS": null, + "Terraform": "cpu_prepaid" + }, + { + "ROS": null, + "Terraform": "engine" + }, + { + "ROS": null, + "Terraform": "engine_minor_version" + }, + { + "ROS": null, + "Terraform": "gmt_created" + }, + { + "ROS": null, + "Terraform": "gmt_expired" + }, + { + "ROS": null, + "Terraform": "gmt_modified" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "instance_net_infos" + }, + { + "ROS": null, + "Terraform": "lock_mode" + }, + { + "ROS": null, + "Terraform": "lock_reason" + }, + { + "ROS": null, + "Terraform": "memory_postpaid" + }, + { + "ROS": null, + "Terraform": "memory_prepaid" + }, + { + "ROS": null, + "Terraform": "region_id" + }, + { + "ROS": null, + "Terraform": "security_ip_lists" + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": null, + "Terraform": "sub_domain" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_sms_short_url" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "effective_days", + "Required": false + }, + { + "ROS": null, + "Terraform": "short_url_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_url", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_service_catalog_portfolio" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "portfolio_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "provider_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "portfolio_arn" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_service_catalog_principal_portfolio_association" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "portfolio_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "principal_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "principal_type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_service_catalog_product" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "product_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "product_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "provider_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_service_catalog_product_portfolio_association" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "portfolio_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "product_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_service_catalog_product_version" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "active", + "Required": false + }, + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "guidance", + "Required": false + }, + { + "ROS": null, + "Terraform": "product_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "product_version_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "template_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "template_url", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_service_catalog_provisioned_product" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "parameter_key", + "Required": false + }, + { + "ROS": null, + "Terraform": "parameters", + "Required": false + }, + { + "ROS": null, + "Terraform": "parameter_value", + "Required": false + }, + { + "ROS": null, + "Terraform": "portfolio_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "product_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "product_version_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "provisioned_product_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "stack_region_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "last_provisioning_task_id" + }, + { + "ROS": null, + "Terraform": "last_successful_provisioning_task_id" + }, + { + "ROS": null, + "Terraform": "last_task_id" + }, + { + "ROS": null, + "Terraform": "outputs" + }, + { + "ROS": null, + "Terraform": "owner_principal_id" + }, + { + "ROS": null, + "Terraform": "owner_principal_type" + }, + { + "ROS": null, + "Terraform": "product_name" + }, + { + "ROS": null, + "Terraform": "product_version_name" + }, + { + "ROS": null, + "Terraform": "provisioned_product_arn" + }, + { + "ROS": null, + "Terraform": "provisioned_product_id" + }, + { + "ROS": null, + "Terraform": "provisioned_product_type" + }, + { + "ROS": null, + "Terraform": "stack_id" + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": null, + "Terraform": "status_message" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_tag_meta_tag" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "key", + "Required": false + }, + { + "ROS": null, + "Terraform": "values", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_tag_policy" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "policy_content", + "Required": false + }, + { + "ROS": null, + "Terraform": "policy_desc", + "Required": false + }, + { + "ROS": null, + "Terraform": "policy_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "user_type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_tag_policy_attachment" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "policy_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "target_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "target_type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_threat_detection_backup_policy" + }, + "ProductCode": "sas", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "backup_policy_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "policy", + "Required": false + }, + { + "ROS": null, + "Terraform": "policy_region_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "policy_version", + "Required": false + }, + { + "ROS": null, + "Terraform": "uuid_list", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create" + }, + { + "ROS": null, + "Terraform": "delete" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": null, + "Terraform": "update" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_threat_detection_baseline_strategy" + }, + "ProductCode": "sas", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "baseline_strategy_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "custom_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "cycle_days", + "Required": false + }, + { + "ROS": null, + "Terraform": "cycle_start_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "end_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "risk_sub_type_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "start_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "target_type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "baseline_strategy_id" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_threat_detection_client_file_protect" + }, + "ProductCode": "sas", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "alert_level", + "Required": false + }, + { + "ROS": null, + "Terraform": "file_ops", + "Required": false + }, + { + "ROS": null, + "Terraform": "file_paths", + "Required": false + }, + { + "ROS": null, + "Terraform": "proc_paths", + "Required": false + }, + { + "ROS": null, + "Terraform": "rule_action", + "Required": false + }, + { + "ROS": null, + "Terraform": "rule_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "status", + "Required": false + }, + { + "ROS": null, + "Terraform": "switch_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_threat_detection_client_user_define_rule" + }, + "ProductCode": "sas", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "action_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "client_user_define_rule_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "cmdline", + "Required": false + }, + { + "ROS": null, + "Terraform": "file_path", + "Required": false + }, + { + "ROS": null, + "Terraform": "hash", + "Required": false + }, + { + "ROS": null, + "Terraform": "ip", + "Required": false + }, + { + "ROS": null, + "Terraform": "new_file_path", + "Required": false + }, + { + "ROS": null, + "Terraform": "parent_cmdline", + "Required": false + }, + { + "ROS": null, + "Terraform": "parent_proc_path", + "Required": false + }, + { + "ROS": null, + "Terraform": "platform", + "Required": false + }, + { + "ROS": null, + "Terraform": "port_str", + "Required": false + }, + { + "ROS": null, + "Terraform": "proc_path", + "Required": false + }, + { + "ROS": null, + "Terraform": "registry_content", + "Required": false + }, + { + "ROS": null, + "Terraform": "registry_key", + "Required": false + }, + { + "ROS": null, + "Terraform": "type", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_threat_detection_file_upload_limit" + }, + "ProductCode": "sas", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "limit", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_threat_detection_honey_pot" + }, + "ProductCode": "sas", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "honeypot_image_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "honeypot_image_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "honeypot_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "node_id", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "honeypot_id" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "preset_id" + }, + { + "ROS": null, + "Terraform": "state" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_threat_detection_honeypot_node" + }, + "ProductCode": "sas", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "allow_honeypot_access_internet", + "Required": false + }, + { + "ROS": null, + "Terraform": "available_probe_num", + "Required": false + }, + { + "ROS": null, + "Terraform": "node_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "security_group_probe_ip_list", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_threat_detection_honeypot_preset" + }, + "ProductCode": "sas", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "honeypot_image_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "meta", + "Required": false + }, + { + "ROS": null, + "Terraform": "node_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "preset_name", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "honeypot_preset_id" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_threat_detection_honeypot_probe" + }, + "ProductCode": "sas", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "arp", + "Required": false + }, + { + "ROS": null, + "Terraform": "bind_port", + "Required": false + }, + { + "ROS": null, + "Terraform": "bind_port_list", + "Required": false + }, + { + "ROS": null, + "Terraform": "control_node_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "display_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "end_port", + "Required": false + }, + { + "ROS": null, + "Terraform": "fixed", + "Required": false + }, + { + "ROS": null, + "Terraform": "honeypot_bind_list", + "Required": false + }, + { + "ROS": null, + "Terraform": "honeypot_id", + "Required": false + }, + { + "ROS": null, + "Terraform": "ping", + "Required": false + }, + { + "ROS": null, + "Terraform": "probe_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "probe_version", + "Required": false + }, + { + "ROS": null, + "Terraform": "proxy_ip", + "Required": false + }, + { + "ROS": null, + "Terraform": "service_ip_list", + "Required": false + }, + { + "ROS": null, + "Terraform": "start_port", + "Required": false + }, + { + "ROS": null, + "Terraform": "target_port", + "Required": false + }, + { + "ROS": null, + "Terraform": "uuid", + "Required": false + }, + { + "ROS": null, + "Terraform": "vpc_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VPC" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "honeypot_probe_id" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "service_ip_list" + }, + { + "ROS": null, + "Terraform": "status" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_threat_detection_image_event_operation" + }, + "ProductCode": "sas", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "conditions", + "Required": false + }, + { + "ROS": null, + "Terraform": "event_key", + "Required": false + }, + { + "ROS": null, + "Terraform": "event_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "event_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "operation_code", + "Required": false + }, + { + "ROS": null, + "Terraform": "scenarios", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_threat_detection_malicious_file_whitelist_config" + }, + "ProductCode": "sas", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "event_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "field", + "Required": false + }, + { + "ROS": null, + "Terraform": "field_value", + "Required": false + }, + { + "ROS": null, + "Terraform": "operator", + "Required": false + }, + { + "ROS": null, + "Terraform": "source", + "Required": false + }, + { + "ROS": null, + "Terraform": "target_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "target_value", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_threat_detection_oss_scan_config" + }, + "ProductCode": "sas", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "all_key_prefix", + "Required": false + }, + { + "ROS": null, + "Terraform": "bucket_name_list", + "Required": false + }, + { + "ROS": null, + "Terraform": "enable", + "Required": false + }, + { + "ROS": null, + "Terraform": "end_time", + "Required": false + }, + { + "ROS": null, + "Terraform": "key_prefix_list", + "Required": false + }, + { + "ROS": null, + "Terraform": "key_suffix_list", + "Required": false + }, + { + "ROS": null, + "Terraform": "oss_scan_config_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "scan_day_list", + "Required": false + }, + { + "ROS": null, + "Terraform": "start_time", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_threat_detection_sas_trail" + }, + "ProductCode": "sas", + "Name": { + "zh": null, + "en": null + }, + "Properties": [], + "Attributes": [ + { + "ROS": null, + "Terraform": "create_time" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "service_trail" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_threat_detection_vul_whitelist" + }, + "ProductCode": "sas", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "reason", + "Required": false + }, + { + "ROS": null, + "Terraform": "target_info", + "Required": false + }, + { + "ROS": null, + "Terraform": "whitelist", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_threat_detection_web_lock_config" + }, + "ProductCode": "sas", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "defence_mode", + "Required": false + }, + { + "ROS": null, + "Terraform": "dir", + "Required": false + }, + { + "ROS": null, + "Terraform": "exclusive_dir", + "Required": false + }, + { + "ROS": null, + "Terraform": "exclusive_file", + "Required": false + }, + { + "ROS": null, + "Terraform": "exclusive_file_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "inclusive_file_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "local_backup_dir", + "Required": false + }, + { + "ROS": null, + "Terraform": "mode", + "Required": false + }, + { + "ROS": null, + "Terraform": "uuid", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_vod_domain" + }, + "ProductCode": "vod", + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "check_url", + "Required": false + }, + { + "ROS": null, + "Terraform": "domain_name", + "Required": false + }, + { + "ROS": null, + "Terraform": "scope", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_content", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_port", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_priority", + "Required": false + }, + { + "ROS": null, + "Terraform": "sources", + "Required": false + }, + { + "ROS": null, + "Terraform": "source_type", + "Required": false + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": null, + "Terraform": "top_level_domain", + "Required": false + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "cert_name" + }, + { + "ROS": null, + "Terraform": "cname" + }, + { + "ROS": null, + "Terraform": "description" + }, + { + "ROS": null, + "Terraform": "domain_name" + }, + { + "ROS": null, + "Terraform": "gmt_created" + }, + { + "ROS": null, + "Terraform": "gmt_modified" + }, + { + "ROS": null, + "Terraform": "id", + "Primary": true + }, + { + "ROS": null, + "Terraform": "scope" + }, + { + "ROS": null, + "Terraform": "sources" + }, + { + "ROS": null, + "Terraform": "ssl_protocol" + }, + { + "ROS": null, + "Terraform": "ssl_pub" + }, + { + "ROS": null, + "Terraform": "status" + }, + { + "ROS": null, + "Terraform": "weight" + } + ] + }, + { + "Version": "2024-12-02", + "Type": "Resource", + "ResourceType": { + "ROS": null, + "Terraform": "alicloud_yundun_dbaudit_instance" + }, + "ProductCode": null, + "Name": { + "zh": null, + "en": null + }, + "Properties": [ + { + "ROS": null, + "Terraform": "description", + "Required": false + }, + { + "ROS": null, + "Terraform": "period", + "Required": false + }, + { + "ROS": null, + "Terraform": "plan_code", + "Required": false + }, + { + "ROS": null, + "Terraform": "resource_group_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ResourceManager::ResourceGroup" + } + ] + }, + { + "ROS": null, + "Terraform": "tags", + "Required": false + }, + { + "ROS": null, + "Terraform": "vswitch_id", + "Required": false, + "RelatedTo": [ + { + "ResourceType": "ROS/ALIYUN::ECS::VSwitch" + } + ] + } + ], + "Attributes": [ + { + "ROS": null, + "Terraform": "id", + "Primary": true + } + ] + } +] \ No newline at end of file diff --git a/src/iac_code/pipeline/engine/architecture_metas/products.json b/src/iac_code/pipeline/engine/architecture_metas/products.json new file mode 100644 index 00000000..bd0e6bc2 --- /dev/null +++ b/src/iac_code/pipeline/engine/architecture_metas/products.json @@ -0,0 +1,1432 @@ +[ + { + "ProductCode": "acms", + "RelevantCodes": { + "ROS": "ACM", + "PIP": "acms" + }, + "Name": { + "zh": "应用配置管理", + "en": "Application Configuration Management" + } + }, + { + "ProductCode": "acr", + "RelevantCodes": { + "ROS": "CR", + "PIP": "acr" + }, + "Name": { + "zh": "容器镜像服务", + "en": "Container Registry" + } + }, + { + "ProductCode": "acs", + "RelevantCodes": { + "ROS": "ACS", + "PIP": "acs" + }, + "Name": { + "zh": "容器计算服务", + "en": "Container Compute Service" + } + }, + { + "ProductCode": "acs", + "RelevantCodes": { + "ROS": "CS", + "PIP": "acs" + }, + "Name": { + "zh": "容器计算服务", + "en": "Container Compute Service" + } + }, + { + "ProductCode": "actiontrail", + "RelevantCodes": { + "ROS": "ACTIONTRAIL", + "PIP": "actiontrail" + }, + "Name": { + "zh": "操作审计", + "en": "ActionTrail" + } + }, + { + "ProductCode": "adb", + "RelevantCodes": { + "ROS": "ADB", + "PIP": "adb" + }, + "Name": { + "zh": "云原生数据仓库 AnalyticDB", + "en": "AnalyticDB" + } + }, + { + "ProductCode": "slb", + "RelevantCodes": { + "ROS": "ALB", + "PIP": "slb" + }, + "Name": { + "zh": "应用负载均衡", + "en": "Application Load Balancer" + } + }, + { + "ProductCode": "alidfs", + "RelevantCodes": { + "ROS": "DFS", + "PIP": "alidfs" + }, + "Name": { + "zh": "文件存储HDFS版", + "en": "Apsara File Storage for HDFS" + } + }, + { + "ProductCode": "alikafka", + "RelevantCodes": { + "ROS": "KAFKA", + "PIP": "alikafka" + }, + "Name": { + "zh": "云消息队列 Kafka 版", + "en": "ApsaraMQ for Kafka" + } + }, + { + "ProductCode": "apigateway", + "RelevantCodes": { + "ROS": "APIG", + "PIP": "apigateway" + }, + "Name": { + "zh": "云原生API网关", + "en": "Cloud-native API Gateway" + } + }, + { + "ProductCode": "apigateway", + "RelevantCodes": { + "ROS": "ApiGateway", + "PIP": "apigateway" + }, + "Name": { + "zh": "API 网关", + "en": "API Gateway" + } + }, + { + "ProductCode": "arms", + "RelevantCodes": { + "ROS": "ARMS", + "PIP": "arms" + }, + "Name": { + "zh": "应用实时监控服务", + "en": "Application Real-Time Monitoring Service" + } + }, + { + "ProductCode": "asm", + "RelevantCodes": { + "ROS": "ASM", + "PIP": "asm" + }, + "Name": { + "zh": "应用运维平台", + "en": "Application Operation Platform" + } + }, + { + "ProductCode": "bastionhost", + "RelevantCodes": { + "ROS": "BastionHost", + "PIP": "bastionhost" + }, + "Name": { + "zh": "运维安全中心（堡垒机）", + "en": "Bastionhost" + } + }, + { + "ProductCode": "bss", + "RelevantCodes": { + "ROS": "BSS", + "PIP": null + }, + "Name": { + "zh": "交易和账单管理", + "en": "BSS" + } + }, + { + "ProductCode": "bpstudio", + "RelevantCodes": { + "ROS": "BPStudio", + "PIP": "bpstudio" + }, + "Name": { + "zh": "云速搭", + "en": "Cloud Architect Design Tool" + } + }, + { + "ProductCode": "cas", + "RelevantCodes": { + "ROS": "CAS", + "PIP": "cas" + }, + "Name": { + "zh": "数字证书管理服务（原SSL证书）", + "en": "Certificate Management Service (Original SSL Certificate)" + } + }, + { + "ProductCode": "cbn", + "RelevantCodes": { + "ROS": "CEN", + "PIP": "cbn" + }, + "Name": { + "zh": "云企业网", + "en": "Cloud Enterprise Network" + } + }, + { + "ProductCode": "cbs", + "RelevantCodes": { + "ROS": "DBS", + "PIP": "cbs" + }, + "Name": { + "zh": "数据库备份", + "en": "Database Backup" + } + }, + { + "ProductCode": "cbwp", + "RelevantCodes": { + "ROS": "WAF", + "PIP": "cbwp" + }, + "Name": { + "zh": "共享带宽", + "en": "Internet Shared Bandwidth" + } + }, + { + "ProductCode": "cddc", + "RelevantCodes": { + "ROS": "CDDC", + "PIP": "cddc" + }, + "Name": { + "zh": "云数据库专属集群", + "en": "ApsaraDB for MyBase" + } + }, + { + "ProductCode": "cdn", + "RelevantCodes": { + "ROS": "CDN", + "PIP": "cdn" + }, + "Name": { + "zh": "CDN", + "en": "CDN" + } + }, + { + "ProductCode": "cds", + "RelevantCodes": { + "ROS": null, + "PIP": "cds" + }, + "Name": { + "zh": "云数据库Cassandra版", + "en": "ApsaraDB for Cassandra" + } + }, + { + "ProductCode": "cfw", + "RelevantCodes": { + "ROS": "CLOUDFW", + "PIP": "cfw" + }, + "Name": { + "zh": "云防火墙", + "en": "Cloud Firewall" + } + }, + { + "ProductCode": "clickhouse", + "RelevantCodes": { + "ROS": "ClickHouse", + "PIP": "clickhouse" + }, + "Name": { + "zh": "云数据库 ClickHouse", + "en": "ApsaraDB for ClickHouse" + } + }, + { + "ProductCode": "cloudphone", + "RelevantCodes": { + "ROS": "CloudPhone", + "PIP": "cloudphone" + }, + "Name": { + "zh": "无影云手机", + "en": "Cloud Phone" + } + }, + { + "ProductCode": "cms", + "RelevantCodes": { + "ROS": "CMS", + "PIP": "cms" + }, + "Name": { + "zh": "云监控", + "en": "Cloud Monitor" + } + }, + { + "ProductCode": "computenest", + "RelevantCodes": { + "ROS": "AppFlow", + "PIP": "computenest" + }, + "Name": { + "zh": "计算巢服务", + "en": "Compute Nest" + } + }, + { + "ProductCode": "computenest", + "RelevantCodes": { + "ROS": "ComputeNest", + "PIP": "computenest" + }, + "Name": { + "zh": "计算巢服务", + "en": "Compute Nest" + } + }, + { + "ProductCode": "config", + "RelevantCodes": { + "ROS": "Config", + "PIP": "config" + }, + "Name": { + "zh": "配置审计", + "en": "CloudConfig" + } + }, + { + "ProductCode": "dashvector", + "RelevantCodes": { + "ROS": "DashVector", + "PIP": "dashvector" + }, + "Name": { + "zh": "向量检索服务", + "en": "Vector Retrieval Service" + } + }, + { + "ProductCode": "datahub", + "RelevantCodes": { + "ROS": "DATAHUB", + "PIP": "datahub" + }, + "Name": { + "zh": "数据总线 DataHub", + "en": "DataHub" + } + }, + { + "ProductCode": "dcdn", + "RelevantCodes": { + "ROS": "DCDN", + "PIP": "dcdn" + }, + "Name": { + "zh": "边缘安全加速", + "en": "Edge Security Acceleration" + } + }, + { + "ProductCode": "ddos", + "RelevantCodes": { + "ROS": "DDoS", + "PIP": "ddos" + }, + "Name": { + "zh": "DDoS防护", + "en": "Anti-DDoS" + } + }, + { + "ProductCode": "ddos", + "RelevantCodes": { + "ROS": "DDoSPro", + "PIP": "ddos" + }, + "Name": { + "zh": "DDoS防护", + "en": "Anti-DDoS" + } + }, + { + "ProductCode": "devs", + "RelevantCodes": { + "ROS": "ServerlessDev", + "PIP": "devs" + }, + "Name": { + "zh": "云原生应用开发平台 CAP", + "en": "Cloud Application Platform" + } + }, + { + "ProductCode": "dide", + "RelevantCodes": { + "ROS": "DataWorks", + "PIP": "dide" + }, + "Name": { + "zh": "大数据开发治理平台 DataWorks", + "en": "DataWorks" + } + }, + { + "ProductCode": "dide", + "RelevantCodes": { + "ROS": "DataWorks", + "PIP": "dide" + }, + "Name": { + "zh": "大数据开发治理平台 DataWorks", + "en": "DataWorks" + } + }, + { + "ProductCode": "directmail", + "RelevantCodes": { + "ROS": "DirectMail", + "PIP": "directmail" + }, + "Name": { + "zh": "邮件推送", + "en": "Direct Mail" + } + }, + { + "ProductCode": "disk", + "RelevantCodes": { + "ROS": "EBS", + "PIP": "disk" + }, + "Name": { + "zh": "块存储", + "en": "Elastic Block Storage" + } + }, + { + "ProductCode": "dlf", + "RelevantCodes": { + "ROS": "DLF", + "PIP": "dlf" + }, + "Name": { + "zh": "数据湖构建", + "en": "Data Lake Formation" + } + }, + { + "ProductCode": "dms", + "RelevantCodes": { + "ROS": "DMS", + "PIP": "dms" + }, + "Name": { + "zh": "数据管理", + "en": "Data Management" + } + }, + { + "ProductCode": "dns", + "RelevantCodes": { + "ROS": "DNS", + "PIP": "dns" + }, + "Name": { + "zh": "云解析DNS", + "en": "Alibaba Cloud DNS" + } + }, + { + "ProductCode": "drds", + "RelevantCodes": { + "ROS": "DRDS", + "PIP": "drds" + }, + "Name": { + "zh": "云原生分布式数据库 PolarDB-X", + "en": "PolarDB-X" + } + }, + { + "ProductCode": "dts", + "RelevantCodes": { + "ROS": "DTS", + "PIP": "dts" + }, + "Name": { + "zh": "数据传输服务", + "en": "Data Transmission Service" + } + }, + { + "ProductCode": "eais", + "RelevantCodes": { + "ROS": "EAIS", + "PIP": "eais" + }, + "Name": { + "zh": "弹性加速计算实例", + "en": "Elastic Accelerated Computing Instances" + } + }, + { + "ProductCode": "ecd", + "RelevantCodes": { + "ROS": "ECD", + "PIP": "ecd" + }, + "Name": { + "zh": "边缘云桌面", + "en": "Edge Cloud Desktop" + } + }, + { + "ProductCode": "eci", + "RelevantCodes": { + "ROS": "ECI", + "PIP": "eci" + }, + "Name": { + "zh": "弹性容器实例", + "en": "Elastic Container Instance" + } + }, + { + "ProductCode": "ecs", + "RelevantCodes": { + "ROS": "ECS", + "PIP": "ecs" + }, + "Name": { + "zh": "云服务器 ECS", + "en": "Elastic Compute Service" + } + }, + { + "ProductCode": "edas", + "RelevantCodes": { + "ROS": "EDAS", + "PIP": "edas" + }, + "Name": { + "zh": "企业级分布式应用服务", + "en": "Enterprise Distributed Application Service" + } + }, + { + "ProductCode": "ehpc", + "RelevantCodes": { + "ROS": "EHPC", + "PIP": "ehpc" + }, + "Name": { + "zh": "弹性高性能计算", + "en": "Elastic High Performance Computing" + } + }, + { + "ProductCode": "eip", + "RelevantCodes": { + "ROS": "EIP", + "PIP": "eip" + }, + "Name": { + "zh": "弹性公网IP", + "en": "Elastic IP Address" + } + }, + { + "ProductCode": "eip", + "RelevantCodes": { + "ROS": "Eipanycast", + "PIP": "eip" + }, + "Name": { + "zh": "弹性公网IP", + "en": "Elastic IP Address" + } + }, + { + "ProductCode": "eip", + "RelevantCodes": { + "ROS": "VPC", + "PIP": "eip" + }, + "Name": { + "zh": "弹性公网IP", + "en": "Elastic IP Address" + } + }, + { + "ProductCode": "elasticsearch", + "RelevantCodes": { + "ROS": "ElasticSearch", + "PIP": "elasticsearch" + }, + "Name": { + "zh": "检索分析服务 Elasticsearch版", + "en": "Elasticsearch" + } + }, + { + "ProductCode": "elasticsearch", + "RelevantCodes": { + "ROS": "ElasticSearchServerless", + "PIP": "elasticsearch" + }, + "Name": { + "zh": "检索分析服务 Elasticsearch版", + "en": "Elasticsearch" + } + }, + { + "ProductCode": "emapreduce", + "RelevantCodes": { + "ROS": "EMR", + "PIP": "emapreduce" + }, + "Name": { + "zh": "开源大数据平台 E-MapReduce", + "en": "E-MapReduce" + } + }, + { + "ProductCode": "ens", + "RelevantCodes": { + "ROS": "ENS", + "PIP": "ens" + }, + "Name": { + "zh": "边缘节点服务 ENS", + "en": "Edge Node Service" + } + }, + { + "ProductCode": "entconsole", + "RelevantCodes": { + "ROS": "ResourceManager", + "PIP": "entconsole" + }, + "Name": { + "zh": "资源管理", + "en": "Resource Management" + } + }, + { + "ProductCode": "ess", + "RelevantCodes": { + "ROS": "ESS", + "PIP": "ess" + }, + "Name": { + "zh": "弹性伸缩", + "en": "Auto Scaling" + } + }, + { + "ProductCode": "eventbridge", + "RelevantCodes": { + "ROS": "EventBridge", + "PIP": "eventbridge" + }, + "Name": { + "zh": "事件总线", + "en": "EventBridge" + } + }, + { + "ProductCode": "fc", + "RelevantCodes": { + "ROS": "FC", + "PIP": "fc" + }, + "Name": { + "zh": "函数计算", + "en": "Function Compute" + } + }, + { + "ProductCode": "fc", + "RelevantCodes": { + "ROS": "FC3", + "PIP": "fc" + }, + "Name": { + "zh": "函数计算", + "en": "Function Compute" + } + }, + { + "ProductCode": "fnf", + "RelevantCodes": { + "ROS": "FNF", + "PIP": "fnf" + }, + "Name": { + "zh": "云工作流", + "en": "CloudFlow" + } + }, + { + "ProductCode": "ga", + "RelevantCodes": { + "ROS": "GA", + "PIP": "ga" + }, + "Name": { + "zh": "全球加速", + "en": "Global Accelerator" + } + }, + { + "ProductCode": "gds", + "RelevantCodes": { + "ROS": "GraphDatabase", + "PIP": "gds" + }, + "Name": { + "zh": "图数据库", + "en": "Graph Database" + } + }, + { + "ProductCode": "gpdb", + "RelevantCodes": { + "ROS": "GPDB", + "PIP": "gpdb" + }, + "Name": { + "zh": "云原生数据仓库 AnalyticDB PostgreSQL版", + "en": "AnalyticDB for PostgreSQL" + } + }, + { + "ProductCode": "gws", + "RelevantCodes": { + "ROS": "EdsUser", + "PIP": "gws" + }, + "Name": { + "zh": "无影云电脑", + "en": "Elastic Desktop Service" + } + }, + { + "ProductCode": "hbase", + "RelevantCodes": { + "ROS": "HBase", + "PIP": "hbase" + }, + "Name": { + "zh": "云数据库HBase版", + "en": "ApsaraDB for Hbase" + } + }, + { + "ProductCode": "hbr", + "RelevantCodes": { + "ROS": "HBR", + "PIP": "hbr" + }, + "Name": { + "zh": "云备份", + "en": "Cloud Backup" + } + }, + { + "ProductCode": "hcs_sgw", + "RelevantCodes": { + "ROS": "CloudStorageGateway", + "PIP": "hcs_sgw" + }, + "Name": { + "zh": "云存储网关", + "en": "Cloud Storage Gateway" + } + }, + { + "ProductCode": "hitsdb", + "RelevantCodes": { + "ROS": "Lindorm", + "PIP": "hitsdb" + }, + "Name": { + "zh": "云原生多模数据库 Lindorm", + "en": "Lindorm" + } + }, + { + "ProductCode": "hitsdb", + "RelevantCodes": { + "ROS": "TSDB", + "PIP": "hitsdb" + }, + "Name": { + "zh": "云原生多模数据库 Lindorm", + "en": "Lindorm" + } + }, + { + "ProductCode": "hologram", + "RelevantCodes": { + "ROS": "Hologram", + "PIP": "hologram" + }, + "Name": { + "zh": "实时数仓 Hologres", + "en": "Hologres" + } + }, + { + "ProductCode": "ice", + "RelevantCodes": { + "ROS": "ICE", + "PIP": "ice" + }, + "Name": { + "zh": "智能媒体服务", + "en": "Intelligent Media Services" + } + }, + { + "ProductCode": "imm", + "RelevantCodes": { + "ROS": "IMM", + "PIP": "imm" + }, + "Name": { + "zh": "智能媒体管理", + "en": "Intelligent Media Management" + } + }, + { + "ProductCode": "iot", + "RelevantCodes": { + "ROS": "IOT", + "PIP": "iot" + }, + "Name": { + "zh": "物联网平台", + "en": "IoT Platform" + } + }, + { + "ProductCode": "kms", + "RelevantCodes": { + "ROS": "KMS", + "PIP": "kms" + }, + "Name": { + "zh": "密钥管理服务", + "en": "Key Management Service" + } + }, + { + "ProductCode": "kvstore", + "RelevantCodes": { + "ROS": "REDIS", + "PIP": "kvstore" + }, + "Name": { + "zh": "云数据库 Tair（兼容 Redis）", + "en": "Tair (Redis OSS-compatible)" + } + }, + { + "ProductCode": "learn", + "RelevantCodes": { + "ROS": "PAI", + "PIP": "learn" + }, + "Name": { + "zh": "人工智能平台 PAI", + "en": "Platform for AI" + } + }, + { + "ProductCode": "learn", + "RelevantCodes": { + "ROS": "PAIDLC", + "PIP": "learn" + }, + "Name": { + "zh": "人工智能平台 PAI", + "en": "Platform for AI" + } + }, + { + "ProductCode": "learn", + "RelevantCodes": { + "ROS": "PAIDatasetAcc", + "PIP": "learn" + }, + "Name": { + "zh": "人工智能平台 PAI", + "en": "Platform for AI" + } + }, + { + "ProductCode": "learn", + "RelevantCodes": { + "ROS": "PAIPlugin", + "PIP": "learn" + }, + "Name": { + "zh": "人工智能平台 PAI", + "en": "Platform for AI" + } + }, + { + "ProductCode": "learn", + "RelevantCodes": { + "ROS": "PaiDswApi", + "PIP": "learn" + }, + "Name": { + "zh": "人工智能平台 PAI", + "en": "Platform for AI" + } + }, + { + "ProductCode": "lvwang", + "RelevantCodes": { + "ROS": "Aligreen", + "PIP": "lvwang" + }, + "Name": { + "zh": "内容安全", + "en": "Content Moderation" + } + }, + { + "ProductCode": "marketplace", + "RelevantCodes": { + "ROS": "MarketPlace", + "PIP": null + }, + "Name": { + "zh": "云市场", + "en": "Marketplace" + } + }, + { + "ProductCode": "miniappdev", + "RelevantCodes": { + "ROS": "MOBI", + "PIP": "miniappdev" + }, + "Name": { + "zh": "多端低代码开发平台魔笔", + "en": "Low-Code Development Platform" + } + }, + { + "ProductCode": "mns", + "RelevantCodes": { + "ROS": "MNS", + "PIP": "mns" + }, + "Name": { + "zh": "轻量消息队列（原 MNS）", + "en": "Simple Message Queue (formerly MNS)" + } + }, + { + "ProductCode": "mongodb", + "RelevantCodes": { + "ROS": "MONGODB", + "PIP": "mongodb" + }, + "Name": { + "zh": "云数据库 MongoDB 版", + "en": "ApsaraDB for MongoDB" + } + }, + { + "ProductCode": "mse", + "RelevantCodes": { + "ROS": "MSE", + "PIP": "mse" + }, + "Name": { + "zh": "微服务引擎", + "en": "Microservices Engine" + } + }, + { + "ProductCode": "mts", + "RelevantCodes": { + "ROS": "MPS", + "PIP": "mts" + }, + "Name": { + "zh": "媒体处理", + "en": "ApsaraVideo Media Processing" + } + }, + { + "ProductCode": "nas", + "RelevantCodes": { + "ROS": "NAS", + "PIP": "nas" + }, + "Name": { + "zh": "文件存储 NAS", + "en": "File Storage NAS" + } + }, + { + "ProductCode": "nat", + "RelevantCodes": { + "ROS": "VPC", + "PIP": "nat" + }, + "Name": { + "zh": "NAT网关", + "en": "NAT Gateway" + } + }, + { + "ProductCode": "nlb", + "RelevantCodes": { + "ROS": "NLB", + "PIP": "nlb" + }, + "Name": { + "zh": "网络负载均衡", + "en": "Network Load Balancer" + } + }, + { + "ProductCode": "nlp", + "RelevantCodes": { + "ROS": "NLPAUTOML", + "PIP": "nlp" + }, + "Name": { + "zh": "自然语言处理", + "en": "Natural Language Processing" + } + }, + { + "ProductCode": "nls", + "RelevantCodes": { + "ROS": "NLS", + "PIP": "nls" + }, + "Name": { + "zh": "智能语音交互", + "en": "Intelligent Speech Interaction" + } + }, + { + "ProductCode": "ocs", + "RelevantCodes": { + "ROS": "Memcache", + "PIP": "ocs" + }, + "Name": { + "zh": "云数据库 Memcache 版", + "en": "ApsaraDB for Memcache" + } + }, + { + "ProductCode": "odps", + "RelevantCodes": { + "ROS": "MaxCompute", + "PIP": "odps" + }, + "Name": { + "zh": "云原生大数据计算服务 MaxCompute", + "en": "MaxCompute" + } + }, + { + "ProductCode": "ons", + "RelevantCodes": { + "ROS": "AMQP", + "PIP": "ons" + }, + "Name": { + "zh": "云消息队列 MQ", + "en": "ApsaraMQ" + } + }, + { + "ProductCode": "ons", + "RelevantCodes": { + "ROS": "ROCKETMQ", + "PIP": "ons" + }, + "Name": { + "zh": "云消息队列 MQ", + "en": "ApsaraMQ" + } + }, + { + "ProductCode": "ons", + "RelevantCodes": { + "ROS": "ROCKETMQ5", + "PIP": "ons" + }, + "Name": { + "zh": "云消息队列 MQ", + "en": "ApsaraMQ" + } + }, + { + "ProductCode": "oos", + "RelevantCodes": { + "ROS": "OOS", + "PIP": "oos" + }, + "Name": { + "zh": "系统运维管理", + "en": "CloudOps Orchestration Service" + } + }, + { + "ProductCode": "openanalytics", + "RelevantCodes": { + "ROS": "ADBLake", + "PIP": "openanalytics" + }, + "Name": { + "zh": "云原生数据湖分析", + "en": "Data Lake Analytics" + } + }, + { + "ProductCode": "opensearch", + "RelevantCodes": { + "ROS": "SearchEngine", + "PIP": "opensearch" + }, + "Name": { + "zh": "智能开放搜索 OpenSearch", + "en": "Open Search" + } + }, + { + "ProductCode": "oss", + "RelevantCodes": { + "ROS": "OSS", + "PIP": "oss" + }, + "Name": { + "zh": "对象存储", + "en": "Object Storage Service" + } + }, + { + "ProductCode": "ots", + "RelevantCodes": { + "ROS": "OTS", + "PIP": "ots" + }, + "Name": { + "zh": "表格存储", + "en": "Tablestore" + } + }, + { + "ProductCode": "polardb", + "RelevantCodes": { + "ROS": "POLARDB", + "PIP": "polardb" + }, + "Name": { + "zh": "云原生数据库 PolarDB", + "en": "PolarDB" + } + }, + { + "ProductCode": "polardb", + "RelevantCodes": { + "ROS": "PolarDBX", + "PIP": "PolarDB" + }, + "Name": { + "zh": "云原生数据库 PolarDB", + "en": "PolarDB" + } + }, + { + "ProductCode": "privatelink", + "RelevantCodes": { + "ROS": "PrivateLink", + "PIP": "privatelink" + }, + "Name": { + "zh": "私网连接", + "en": "PrivateLink" + } + }, + { + "ProductCode": "pvtz", + "RelevantCodes": { + "ROS": "PVTZ", + "PIP": "pvtz" + }, + "Name": { + "zh": "云解析 PrivateZone", + "en": "Alibaba Cloud DNS PrivateZone" + } + }, + { + "ProductCode": "ram", + "RelevantCodes": { + "ROS": "CloudSSO", + "PIP": "ram" + }, + "Name": { + "zh": "访问控制", + "en": "Resource Access Management" + } + }, + { + "ProductCode": "ram", + "RelevantCodes": { + "ROS": "RAM", + "PIP": "ram" + }, + "Name": { + "zh": "访问控制", + "en": "Resource Access Management" + } + }, + { + "ProductCode": "rdc", + "RelevantCodes": { + "ROS": "DEVOPS", + "PIP": "rdc" + }, + "Name": { + "zh": "云效", + "en": "Apsara Devops" + } + }, + { + "ProductCode": "rds", + "RelevantCodes": { + "ROS": "RDS", + "PIP": "rds" + }, + "Name": { + "zh": "云数据库 RDS", + "en": "ApsaraDB RDS" + } + }, + { + "ProductCode": "ros", + "RelevantCodes": { + "ROS": "ROS", + "PIP": "ros" + }, + "Name": { + "zh": "资源编排", + "en": "Resource Orchestration Service" + } + }, + { + "ProductCode": "sae", + "RelevantCodes": { + "ROS": "SAE", + "PIP": "sae" + }, + "Name": { + "zh": "Serverless 应用引擎", + "en": "Serverless App Engine" + } + }, + { + "ProductCode": "sas", + "RelevantCodes": { + "ROS": "SAS", + "PIP": "sas" + }, + "Name": { + "zh": "云安全中心", + "en": "Security Center" + } + }, + { + "ProductCode": "sas", + "RelevantCodes": { + "ROS": "ThreatDetection", + "PIP": "sas" + }, + "Name": { + "zh": "云安全中心", + "en": "Security Center" + } + }, + { + "ProductCode": "sc", + "RelevantCodes": { + "ROS": "FOAS", + "PIP": "sc" + }, + "Name": { + "zh": "实时计算 Flink版", + "en": "Realtime Compute for Apache Flink" + } + }, + { + "ProductCode": "sc", + "RelevantCodes": { + "ROS": "Flink", + "PIP": "sc" + }, + "Name": { + "zh": "实时计算 Flink版", + "en": "Realtime Compute for Apache Flink" + } + }, + { + "ProductCode": "slb", + "RelevantCodes": { + "ROS": "SLB", + "PIP": "slb" + }, + "Name": { + "zh": "负载均衡", + "en": "Server Load Balancer" + } + }, + { + "ProductCode": "sls", + "RelevantCodes": { + "ROS": "SLS", + "PIP": "sls" + }, + "Name": { + "zh": "日志服务", + "en": "Simple Log Service" + } + }, + { + "ProductCode": "smartag", + "RelevantCodes": { + "ROS": "SAG", + "PIP": "smartag" + }, + "Name": { + "zh": "智能接入网关", + "en": "Smart Access Gateway" + } + }, + { + "ProductCode": "swas", + "RelevantCodes": { + "ROS": "SWAS", + "PIP": "swas" + }, + "Name": { + "zh": "轻量应用服务器", + "en": "Simple Application Server" + } + }, + { + "ProductCode": "vod", + "RelevantCodes": { + "ROS": "VOD", + "PIP": "vod" + }, + "Name": { + "zh": "视频点播", + "en": "ApsaraVideo VOD" + } + }, + { + "ProductCode": "vpc", + "RelevantCodes": { + "ROS": "VPC", + "PIP": "vpc" + }, + "Name": { + "zh": "专有网络VPC", + "en": "Virtual Private Cloud" + } + }, + { + "ProductCode": "vpn", + "RelevantCodes": { + "ROS": "VPC", + "PIP": "vpn" + }, + "Name": { + "zh": "VPN网关", + "en": "VPN Gateway" + } + }, + { + "ProductCode": "vs", + "RelevantCodes": { + "ROS": "VS", + "PIP": "vs" + }, + "Name": { + "zh": "视图计算", + "en": "Visual Edge Computing Service" + } + }, + { + "ProductCode": "waf", + "RelevantCodes": { + "ROS": "WAF", + "PIP": "waf" + }, + "Name": { + "zh": "Web应用防火墙", + "en": "Web Application Firewall" + } + }, + { + "ProductCode": "waf", + "RelevantCodes": { + "ROS": "WAF3", + "PIP": "waf" + }, + "Name": { + "zh": "Web应用防火墙", + "en": "Web Application Firewall" + } + } +] \ No newline at end of file diff --git a/src/iac_code/pipeline/engine/architecture_resource_inventory.py b/src/iac_code/pipeline/engine/architecture_resource_inventory.py new file mode 100644 index 00000000..dec7deb7 --- /dev/null +++ b/src/iac_code/pipeline/engine/architecture_resource_inventory.py @@ -0,0 +1,299 @@ +"""ROS resource type inventory used by architecture rule extraction.""" + +from __future__ import annotations + +import asyncio +import json +from collections.abc import Mapping +from dataclasses import dataclass +from pathlib import Path +from typing import Any, Protocol + +from iac_code.pipeline.engine.architecture_meta import ArchitectureMetaRepository, ResourceMeta +from iac_code.tools.base import ToolContext +from iac_code.tools.cloud.aliyun.aliyun_api import AliyunApi + + +@dataclass(frozen=True) +class RosResourceTypeDetail: + resource_type: str + entity_type: str | None + provider: str | None + properties: dict[str, dict[str, Any]] + attributes: dict[str, Any] + support_drift_detection: bool | None = None + support_scratch_detection: bool | None = None + description: str | None = None + + @classmethod + def from_api_response(cls, raw: dict[str, Any]) -> RosResourceTypeDetail | None: + resource_type = raw.get("ResourceType") + if not isinstance(resource_type, str) or not resource_type: + return None + properties = raw.get("Properties") + attributes = raw.get("Attributes") + return cls( + resource_type=resource_type, + entity_type=raw.get("EntityType") if isinstance(raw.get("EntityType"), str) else None, + provider=raw.get("Provider") if isinstance(raw.get("Provider"), str) else None, + properties=_dict_of_dicts(properties), + attributes=attributes if isinstance(attributes, dict) else {}, + support_drift_detection=_bool_or_none(raw.get("SupportDriftDetection")), + support_scratch_detection=_bool_or_none(raw.get("SupportScratchDetection")), + description=raw.get("Description") if isinstance(raw.get("Description"), str) else None, + ) + + @classmethod + def from_dict(cls, raw: Any) -> RosResourceTypeDetail | None: + if not isinstance(raw, dict): + return None + resource_type = raw.get("resource_type") + if not isinstance(resource_type, str) or not resource_type: + return None + return cls( + resource_type=resource_type, + entity_type=raw.get("entity_type") if isinstance(raw.get("entity_type"), str) else None, + provider=raw.get("provider") if isinstance(raw.get("provider"), str) else None, + properties=_dict_of_dicts(raw.get("properties")), + attributes=raw.get("attributes") if isinstance(raw.get("attributes"), dict) else {}, + support_drift_detection=_bool_or_none(raw.get("support_drift_detection")), + support_scratch_detection=_bool_or_none(raw.get("support_scratch_detection")), + description=raw.get("description") if isinstance(raw.get("description"), str) else None, + ) + + def to_dict(self) -> dict[str, Any]: + return { + "resource_type": self.resource_type, + "entity_type": self.entity_type, + "provider": self.provider, + "properties": self.properties, + "attributes": self.attributes, + "support_drift_detection": self.support_drift_detection, + "support_scratch_detection": self.support_scratch_detection, + "description": self.description, + } + + +@dataclass(frozen=True) +class ResourceInventoryItem: + resource_type: str + product_code: str + source_state: str + detail: RosResourceTypeDetail | None + meta: ResourceMeta | None + name_zh: str | None + name_en: str | None + category_code: str | None + + +@dataclass(frozen=True) +class ResourceInventorySnapshot: + items: dict[str, ResourceInventoryItem] + api_resource_types: tuple[str, ...] + local_resource_types: tuple[str, ...] + api_only_resource_types: tuple[str, ...] + local_only_resource_types: tuple[str, ...] + fetched_at: str | None + fetch_errors: dict[str, str] + + +class RosResourceTypeClient(Protocol): + async def list_resource_types(self) -> list[str]: + """Return ROS resource type names from ListResourceTypes.""" + + async def get_resource_type(self, resource_type: str) -> dict[str, Any]: + """Return one ROS GetResourceType response.""" + + +class AliyunRosResourceTypeClient: + """ROS resource type client backed by the project AliyunApi tool.""" + + async def list_resource_types(self) -> list[str]: + body = await self._call("ListResourceTypes", {}) + values = body.get("ResourceTypes") + if not isinstance(values, list): + return [] + return sorted(item for item in values if isinstance(item, str)) + + async def get_resource_type(self, resource_type: str) -> dict[str, Any]: + return await self._call("GetResourceType", {"ResourceType": resource_type}) + + async def _call(self, action: str, params: dict[str, Any]) -> dict[str, Any]: + result = await AliyunApi().execute( + tool_input={"product": "ros", "action": action, "params": params}, + context=ToolContext(), + ) + if result.is_error: + raise RuntimeError(result.content) + body = json.loads(result.content) + return body if isinstance(body, dict) else {} + + +async def collect_ros_resource_inventory( + *, + client: RosResourceTypeClient | None = None, + cache_path: Path | None = None, + meta_repository: ArchitectureMetaRepository | None = None, + fetched_at: str | None = None, + refresh: bool = False, + max_concurrency: int = 8, +) -> ResourceInventorySnapshot: + """Collect an API-authoritative ROS inventory and merge local metadata. + + The cache stores only resource type details and errors. It never stores credentials. + """ + + client = client or AliyunRosResourceTypeClient() + meta_repository = meta_repository or ArchitectureMetaRepository.load_default() + api_resource_types = tuple(sorted(await client.list_resource_types())) + cached_details, cached_errors = _load_inventory_cache(cache_path) + details_by_type = dict(cached_details) + fetch_errors: dict[str, str] = dict(cached_errors) + + missing_types = [ + resource_type + for resource_type in api_resource_types + if refresh or resource_type not in details_by_type or resource_type in fetch_errors + ] + semaphore = asyncio.Semaphore(max(1, max_concurrency)) + + async def fetch_one(resource_type: str) -> None: + async with semaphore: + try: + detail = RosResourceTypeDetail.from_api_response(await client.get_resource_type(resource_type)) + except Exception as exc: # pragma: no cover - exact SDK exceptions are integration-specific + fetch_errors[resource_type] = str(exc) + return + if detail is not None: + details_by_type[resource_type] = detail + fetch_errors.pop(resource_type, None) + + if missing_types: + await asyncio.gather(*(fetch_one(resource_type) for resource_type in missing_types)) + + if cache_path is not None: + _write_inventory_cache( + cache_path=cache_path, + resource_types=api_resource_types, + details_by_type=details_by_type, + fetch_errors=fetch_errors, + ) + + return build_resource_inventory_snapshot( + api_resource_types=api_resource_types, + details_by_type=details_by_type, + meta_repository=meta_repository, + fetched_at=fetched_at, + fetch_errors=fetch_errors, + ) + + +def build_resource_inventory_snapshot( + *, + api_resource_types: list[str] | tuple[str, ...], + details_by_type: Mapping[str, RosResourceTypeDetail | dict[str, Any]], + meta_repository: ArchitectureMetaRepository, + fetched_at: str | None = None, + fetch_errors: dict[str, str] | None = None, +) -> ResourceInventorySnapshot: + api_types = tuple(sorted(dict.fromkeys(api_resource_types))) + local_types = tuple(sorted(meta_repository._resources)) + api_set = set(api_types) + local_set = set(local_types) + + normalized_details: dict[str, RosResourceTypeDetail] = {} + for resource_type, detail in details_by_type.items(): + parsed = detail if isinstance(detail, RosResourceTypeDetail) else RosResourceTypeDetail.from_dict(detail) + if parsed is not None: + normalized_details[resource_type] = parsed + + items: dict[str, ResourceInventoryItem] = {} + for resource_type in sorted(api_set | local_set): + meta = meta_repository.get_resource(resource_type) + detail = normalized_details.get(resource_type) + if resource_type in api_set and meta is not None: + source_state = "api+local" + elif resource_type in api_set: + source_state = "api-only" + else: + source_state = "local-only" + items[resource_type] = ResourceInventoryItem( + resource_type=resource_type, + product_code=_product_code(resource_type, meta), + source_state=source_state, + detail=detail, + meta=meta, + name_zh=meta.name_zh if meta is not None else None, + name_en=meta.name_en if meta is not None else None, + category_code=meta.category_code if meta is not None else None, + ) + + return ResourceInventorySnapshot( + items=items, + api_resource_types=api_types, + local_resource_types=local_types, + api_only_resource_types=tuple(sorted(api_set - local_set)), + local_only_resource_types=tuple(sorted(local_set - api_set)), + fetched_at=fetched_at, + fetch_errors=dict(fetch_errors or {}), + ) + + +def _load_inventory_cache(cache_path: Path | None) -> tuple[dict[str, RosResourceTypeDetail], dict[str, str]]: + if cache_path is None or not cache_path.exists(): + return {}, {} + raw = json.loads(cache_path.read_text(encoding="utf-8")) + if not isinstance(raw, dict): + return {}, {} + details: dict[str, RosResourceTypeDetail] = {} + raw_details = raw.get("details") + if isinstance(raw_details, dict): + for resource_type, value in raw_details.items(): + if not isinstance(resource_type, str): + continue + detail = RosResourceTypeDetail.from_dict(value) + if detail is not None: + details[resource_type] = detail + errors = { + key: value + for key, value in (raw.get("errors") or {}).items() + if isinstance(key, str) and isinstance(value, str) + } + return details, errors + + +def _write_inventory_cache( + *, + cache_path: Path, + resource_types: tuple[str, ...], + details_by_type: dict[str, RosResourceTypeDetail], + fetch_errors: dict[str, str], +) -> None: + cache_path.parent.mkdir(parents=True, exist_ok=True) + payload = { + "resource_types": list(resource_types), + "details": { + resource_type: detail.to_dict() + for resource_type, detail in sorted(details_by_type.items()) + if resource_type in resource_types + }, + "errors": dict(sorted(fetch_errors.items())), + } + cache_path.write_text(json.dumps(payload, ensure_ascii=False, indent=2, sort_keys=True), encoding="utf-8") + + +def _dict_of_dicts(value: Any) -> dict[str, dict[str, Any]]: + if not isinstance(value, dict): + return {} + return {key: item for key, item in value.items() if isinstance(key, str) and isinstance(item, dict)} + + +def _bool_or_none(value: Any) -> bool | None: + return value if isinstance(value, bool) else None + + +def _product_code(resource_type: str, meta: ResourceMeta | None) -> str: + if meta is not None and meta.product_code: + return meta.product_code + parts = resource_type.split("::") + return parts[1].lower() if len(parts) >= 2 else "unknown" diff --git a/src/iac_code/pipeline/engine/architecture_rule_candidates.py b/src/iac_code/pipeline/engine/architecture_rule_candidates.py new file mode 100644 index 00000000..582c6b18 --- /dev/null +++ b/src/iac_code/pipeline/engine/architecture_rule_candidates.py @@ -0,0 +1,690 @@ +"""Rule candidate extraction for ROS architecture diagram metadata.""" + +from __future__ import annotations + +import re +from collections import defaultdict +from dataclasses import dataclass +from typing import Any + +from iac_code.pipeline.engine.architecture_resource_inventory import ResourceInventoryItem, ResourceInventorySnapshot + +RULE_CATEGORIES = ( + "container", + "supplemental_relation", + "display", + "attachment", + "bridge_attachment", + "attachment_edge", + "orchestration_action", + "concept_node", +) + +DECISION_PRIORITY = { + "container": 100, + "concept_node": 90, + "orchestration_action": 80, + "bridge_attachment": 70, + "attachment_edge": 65, + "attachment": 60, + "supplemental_relation": 30, + "display": 10, +} + +HIGH_CONFIDENCE_DECISIONS = { + "container", + "concept_node", + "orchestration_action", + "bridge_attachment", + "attachment_edge", + "attachment", +} + + +@dataclass(frozen=True) +class RuleCandidate: + category: str + resource_type: str + product_code: str + property_name: str | None + target_resource_types: tuple[str, ...] + confidence: str + evidence: tuple[str, ...] + suggested_config: dict[str, Any] + + +@dataclass(frozen=True) +class ResourceTypeDecision: + resource_type: str + product_code: str + decision: str + source_state: str + candidate_categories: tuple[str, ...] + evidence: tuple[str, ...] + + +def extract_rule_candidates(snapshot: ResourceInventorySnapshot) -> list[RuleCandidate]: + candidates: list[RuleCandidate] = [] + api_items = [snapshot.items[resource_type] for resource_type in snapshot.api_resource_types] + known_resource_types = tuple(snapshot.api_resource_types) + + for item in api_items: + candidates.extend(_display_candidates(item)) + candidates.extend(_container_candidates(item)) + candidates.extend(_supplemental_relation_candidates(item)) + candidates.extend(_attachment_candidates(item)) + candidates.extend(_attachment_edge_candidates(item, known_resource_types)) + candidates.extend(_orchestration_action_candidates(item)) + candidates.extend(_concept_node_candidates(item)) + + candidates.extend(_bridge_attachment_candidates(api_items)) + return _dedupe_candidates(candidates) + + +def build_resource_type_decisions( + snapshot: ResourceInventorySnapshot, + candidates: list[RuleCandidate], +) -> dict[str, ResourceTypeDecision]: + candidates_by_type: dict[str, list[RuleCandidate]] = defaultdict(list) + for candidate in candidates: + candidates_by_type[candidate.resource_type].append(candidate) + + decisions: dict[str, ResourceTypeDecision] = {} + for resource_type in snapshot.api_resource_types: + item = snapshot.items[resource_type] + resource_candidates = sorted( + candidates_by_type.get(resource_type, ()), + key=lambda candidate: DECISION_PRIORITY.get(candidate.category, 0), + reverse=True, + ) + categories = tuple(dict.fromkeys(candidate.category for candidate in resource_candidates)) + if item.source_state == "api-only" and not _has_high_confidence_candidate(resource_candidates): + decisions[resource_type] = ResourceTypeDecision( + resource_type=resource_type, + product_code=item.product_code, + decision="needs_review", + source_state=item.source_state, + candidate_categories=categories, + evidence=_api_only_evidence(item), + ) + continue + if resource_candidates: + winner = resource_candidates[0] + decisions[resource_type] = ResourceTypeDecision( + resource_type=resource_type, + product_code=item.product_code, + decision=winner.category, + source_state=item.source_state, + candidate_categories=categories, + evidence=winner.evidence, + ) + continue + decisions[resource_type] = ResourceTypeDecision( + resource_type=resource_type, + product_code=item.product_code, + decision="core_node", + source_state=item.source_state, + candidate_categories=(), + evidence=("No compacting rule candidate matched; keep as a visible resource node.",), + ) + return decisions + + +def render_rule_candidate_report_markdown( + snapshot: ResourceInventorySnapshot, + candidates: list[RuleCandidate], + decisions: dict[str, ResourceTypeDecision], +) -> str: + lines = [ + "# ROS 架构图规则候选报告", + "", + "## Summary", + "", + "| Metric | Count |", + "| --- | ---: |", + f"| API resource types | {len(snapshot.api_resource_types)} |", + f"| Local metadata resource types | {len(snapshot.local_resource_types)} |", + f"| API-only resource types | {len(snapshot.api_only_resource_types)} |", + f"| Local-only resource types | {len(snapshot.local_only_resource_types)} |", + f"| Rule candidates | {len(candidates)} |", + "", + "## Candidate Categories", + "", + ] + + candidates_by_category: dict[str, list[RuleCandidate]] = defaultdict(list) + for candidate in candidates: + candidates_by_category[candidate.category].append(candidate) + for category in RULE_CATEGORIES: + category_candidates = sorted(candidates_by_category.get(category, ()), key=_candidate_sort_key) + if not category_candidates: + continue + lines.extend( + [ + f"### {category}", + "", + "| Resource type | Confidence | Targets | Evidence |", + "| --- | --- | --- | --- |", + ] + ) + for candidate in category_candidates: + evidence = "; ".join(candidate.evidence[:2]).replace("|", "\\|") + targets = ", ".join(f"`{target}`" for target in candidate.target_resource_types) or "-" + lines.append(f"| `{candidate.resource_type}` | `{candidate.confidence}` | {targets} | {evidence} |") + lines.append("") + + lines.extend(["## Decisions by Product", ""]) + decisions_by_product: dict[str, list[ResourceTypeDecision]] = defaultdict(list) + for decision in decisions.values(): + decisions_by_product[decision.product_code].append(decision) + for product_code in sorted(decisions_by_product): + lines.extend( + [ + f"### `{product_code}`", + "", + "| Resource type | Decision | Source | Evidence |", + "| --- | --- | --- | --- |", + ] + ) + for decision in sorted(decisions_by_product[product_code], key=lambda value: value.resource_type): + evidence = "; ".join(decision.evidence[:2]).replace("|", "\\|") + lines.append( + f"| `{decision.resource_type}` | `{decision.decision}` | `{decision.source_state}` | {evidence} |" + ) + lines.append("") + return "\n".join(lines).rstrip() + "\n" + + +def _display_candidates(item: ResourceInventoryItem) -> list[RuleCandidate]: + label = item.name_zh or item.name_en or _short_resource_type(item.resource_type) + evidence = [f"Default display label: {label}."] + if item.detail is not None and item.detail.description: + evidence.append(_shorten_text(item.detail.description)) + return [ + RuleCandidate( + category="display", + resource_type=item.resource_type, + product_code=item.product_code, + property_name=None, + target_resource_types=(), + confidence="medium" if item.meta is not None else "low", + evidence=tuple(evidence), + suggested_config={"label": {"zh": item.name_zh, "en": item.name_en}}, + ) + ] + + +def _container_candidates(item: ResourceInventoryItem) -> list[RuleCandidate]: + short_type = _short_resource_type(item.resource_type) + explicit = { + "ALIYUN::ECS::VPC", + "ALIYUN::ECS::VSwitch", + "ALIYUN::ECS::SecurityGroup", + "ALIYUN::CS::Cluster", + "ALIYUN::ACS::Cluster", + } + if item.resource_type not in explicit and not _looks_like_container_identity(item): + return [] + text = _container_name_text(item) + role = _container_role(short_type, text) + return [ + RuleCandidate( + category="container", + resource_type=item.resource_type, + product_code=item.product_code, + property_name=None, + target_resource_types=(), + confidence="high" if item.resource_type in explicit else "medium", + evidence=(f"{item.resource_type} looks like a {role} boundary/container.",), + suggested_config={ + "network_layer_types": [item.resource_type], + "containment_layer_types": {role: [item.resource_type]}, + }, + ) + ] + + +def _supplemental_relation_candidates(item: ResourceInventoryItem) -> list[RuleCandidate]: + known_names = set(_related_properties(item)) + candidates: list[RuleCandidate] = [] + for name, prop in _detail_properties(item).items(): + if name in known_names or not _looks_like_reference_property(name, prop): + continue + candidates.append( + RuleCandidate( + category="supplemental_relation", + resource_type=item.resource_type, + product_code=item.product_code, + property_name=name, + target_resource_types=(), + confidence="low", + evidence=( + f"GetResourceType property `{name}` looks like a reference but local RelatedTo is missing.", + _shorten_text(str(prop.get("Description") or "")), + ), + suggested_config={"supplemental_related_properties": {item.resource_type: {name: []}}}, + ) + ) + return candidates + + +def _attachment_candidates(item: ResourceInventoryItem) -> list[RuleCandidate]: + candidates: list[RuleCandidate] = [] + meta = item.meta + if meta is not None and meta.main_resource_type is not None: + main_type = meta.main_resource_type.resource_type + candidates.append( + RuleCandidate( + category="attachment", + resource_type=item.resource_type, + product_code=item.product_code, + property_name=meta.main_resource_type.ref_property, + target_resource_types=(main_type,), + confidence="high", + evidence=(f"MainResourceType points to `{main_type}`.",), + suggested_config={"compact_attachment_marker_types": [main_type]}, + ) + ) + + short_type = _short_resource_type(item.resource_type) + text = _resource_identity_text(item) + relation_targets = _all_relation_targets(item) + if not relation_targets: + return candidates + is_attachment_name = any( + token in short_type.lower() + for token in ( + "acl", + "addon", + "association", + "attachment", + "binding", + "addition", + "entry", + "rule", + "securityip", + "whitelist", + ) + ) + is_attachment_desc = any( + token in text for token in ("associate", "attach", "bind", "configure", "entry", "rule", "whitelist") + ) + if is_attachment_name or is_attachment_desc: + candidates.append( + RuleCandidate( + category="attachment", + resource_type=item.resource_type, + product_code=item.product_code, + property_name=None, + target_resource_types=tuple(sorted(relation_targets)), + confidence="medium", + evidence=(f"Name/description indicates auxiliary resource `{short_type}`.",), + suggested_config={ + "compact_child_attachments": [ + { + "resource_types": [item.resource_type], + "target_types": sorted(relation_targets), + } + ] + }, + ) + ) + return candidates + + +def _attachment_edge_candidates( + item: ResourceInventoryItem, + known_resource_types: tuple[str, ...], +) -> list[RuleCandidate]: + related = _related_properties(item) + if not related: + return [] + names = _all_property_names(item) + package_props = [name for name in names if "package" in name.lower() or "bandwidth" in name.lower()] + marker_props = [name for name in names if "eip" in name.lower() or "ip" == name.lower()] + if not package_props or not marker_props: + return [] + source_targets = sorted({target for name in package_props for target in related.get(name, ())}) + marker_targets = sorted({target for name in marker_props for target in related.get(name, ())}) + if not source_targets: + source_targets = sorted(_infer_property_targets(item, package_props, known_resource_types)) + if not marker_targets: + marker_targets = sorted(_infer_property_targets(item, marker_props, known_resource_types)) + if not source_targets or not marker_targets: + return [] + return [ + RuleCandidate( + category="attachment_edge", + resource_type=item.resource_type, + product_code=item.product_code, + property_name=None, + target_resource_types=tuple(source_targets + marker_targets), + confidence="high", + evidence=( + "Resource links an aggregate capability resource with marker resources.", + f"Source properties: {', '.join(package_props)}; marker properties: {', '.join(marker_props)}.", + ), + suggested_config={ + "resource_types": [item.resource_type], + "source_properties": package_props, + "marker_properties": marker_props, + "source_types": source_targets, + "marker_types": marker_targets, + "edge_style": "dotted_open", + }, + ) + ] + + +def _orchestration_action_candidates(item: ResourceInventoryItem) -> list[RuleCandidate]: + text = _resource_identity_text(item) + short_type = _short_resource_type(item.resource_type) + action_terms = ("command", "invocation", "run", "enable", "deploy", "execute", "execution") + if not any(term in text for term in action_terms): + return [] + target_properties = tuple( + name for name in _all_property_names(item) if name.lower() in {"instanceid", "instanceids", "targets"} + ) + command_properties = tuple(name for name in _all_property_names(item) if "command" in name.lower()) + return [ + RuleCandidate( + category="orchestration_action", + resource_type=item.resource_type, + product_code=item.product_code, + property_name=None, + target_resource_types=tuple(sorted(_all_relation_targets(item))), + confidence="high" if "command" in short_type.lower() else "medium", + evidence=(f"`{short_type}` describes an action/orchestration resource.",), + suggested_config={ + "resource_types": [item.resource_type], + "command_properties": command_properties, + "target_properties": target_properties, + }, + ) + ] + + +def _concept_node_candidates(item: ResourceInventoryItem) -> list[RuleCandidate]: + text = _item_text(item) + props = set(_all_property_names(item)) + has_controller = any(name.lower().endswith("groupid") for name in props) + has_source = any(name.lower() == "instanceid" for name in props) + if "scaling" not in text or not has_controller or not has_source: + return [] + return [ + RuleCandidate( + category="concept_node", + resource_type=item.resource_type, + product_code=item.product_code, + property_name=None, + target_resource_types=tuple(sorted(_all_relation_targets(item))), + confidence="medium", + evidence=("Scaling configuration links a controller group with a source ECS instance.",), + suggested_config={ + "via_resource_types": [item.resource_type], + "controller_property": _first_matching_property(props, "groupid"), + "source_property": "InstanceId", + }, + ) + ] + + +def _bridge_attachment_candidates(items: list[ResourceInventoryItem]) -> list[RuleCandidate]: + candidates: list[RuleCandidate] = [] + for source in items: + source_related = _related_properties(source) + if not source_related: + continue + source_props = set(_all_property_names(source)) + if not _looks_like_bridge_source(source): + continue + for via in items: + if via.resource_type == source.resource_type or via.product_code != source.product_code: + continue + via_props = set(_all_property_names(via)) + shared_props = sorted(source_props & via_props) + if not shared_props: + continue + via_related = _related_properties(via) + terminal_targets = sorted( + { + target + for prop_name, targets in via_related.items() + if prop_name not in shared_props + for target in targets + if target != source.resource_type + and target + not in { + "ALIYUN::ECS::VPC", + "ALIYUN::ECS::VSwitch", + "ALIYUN::ECS::SecurityGroup", + } + } + ) + if not terminal_targets: + continue + candidates.append( + RuleCandidate( + category="bridge_attachment", + resource_type=source.resource_type, + product_code=source.product_code, + property_name=shared_props[0], + target_resource_types=tuple(terminal_targets), + confidence="medium", + evidence=( + f"`{source.resource_type}` shares `{shared_props[0]}` with `{via.resource_type}`.", + f"`{via.resource_type}` links onward to {', '.join(terminal_targets)}.", + ), + suggested_config={ + "resource_types": [source.resource_type], + "source_properties": shared_props, + "via_resource_types": [via.resource_type], + "via_source_properties": shared_props, + "via_target_properties": [ + prop_name for prop_name in via_related if prop_name not in shared_props + ], + "target_types": terminal_targets, + }, + ) + ) + return candidates + + +def _dedupe_candidates(candidates: list[RuleCandidate]) -> list[RuleCandidate]: + seen: set[tuple[str, str, str | None, tuple[str, ...]]] = set() + deduped: list[RuleCandidate] = [] + for candidate in candidates: + key = ( + candidate.category, + candidate.resource_type, + candidate.property_name, + candidate.target_resource_types, + ) + if key in seen: + continue + seen.add(key) + deduped.append(candidate) + return sorted(deduped, key=_candidate_sort_key) + + +def _candidate_sort_key(candidate: RuleCandidate) -> tuple[str, str, str]: + return (candidate.category, candidate.product_code, candidate.resource_type) + + +def _related_properties(item: ResourceInventoryItem) -> dict[str, tuple[str, ...]]: + if item.meta is None: + return {} + return {prop.name: prop.targets for prop in item.meta.related_properties} + + +def _infer_property_targets( + item: ResourceInventoryItem, + property_names: list[str], + known_resource_types: tuple[str, ...], +) -> set[str]: + detail_properties = _detail_properties(item) + inferred: set[str] = set() + for property_name in property_names: + prop = detail_properties.get(property_name, {}) + text = "{} {}".format(property_name, prop.get("Description") or "").lower() + for resource_type in known_resource_types: + if resource_type == item.resource_type: + continue + if _property_text_mentions_resource(text, resource_type): + inferred.add(resource_type) + return inferred + + +def _property_text_mentions_resource(text: str, resource_type: str) -> bool: + short_type = _short_resource_type(resource_type) + if short_type.lower() in { + "cluster", + "group", + "instance", + "instancegroup", + "namespace", + "resourcegroup", + "rule", + "vpc", + "vswitch", + "workspace", + }: + return False + aliases = {short_type.lower()} + aliases.add(_split_camel_case(short_type).lower()) + if short_type.lower() == "eip": + aliases.update({"eips", "elastic ip", "elastic public ip"}) + return any(len(alias) >= 3 and alias in text for alias in aliases) + + +def _split_camel_case(value: str) -> str: + return re.sub(r"(? dict[str, dict[str, Any]]: + if item.detail is None: + return {} + return item.detail.properties + + +def _all_property_names(item: ResourceInventoryItem) -> tuple[str, ...]: + names = {*_related_properties(item), *_detail_properties(item)} + return tuple(sorted(names)) + + +def _all_relation_targets(item: ResourceInventoryItem) -> set[str]: + return {target for targets in _related_properties(item).values() for target in targets} + + +def _looks_like_reference_property(name: str, prop: dict[str, Any]) -> bool: + lowered_name = name.lower() + if lowered_name.endswith(("id", "ids", "name", "names")): + return True + description = str(prop.get("Description") or "").lower() + return " id of " in description or "the id of" in description or "name of" in description + + +def _looks_like_bridge_source(item: ResourceInventoryItem) -> bool: + text = _item_text(item) + short_type = _short_resource_type(item.resource_type).lower() + return any(token in short_type for token in ("rule", "policy", "access")) or any( + token in text for token in ("permission", "access", "policy", "rule") + ) + + +def _has_high_confidence_candidate(candidates: list[RuleCandidate]) -> bool: + return any(candidate.category in HIGH_CONFIDENCE_DECISIONS for candidate in candidates) + + +def _api_only_evidence(item: ResourceInventoryItem) -> tuple[str, ...]: + evidence = ["Resource type exists in ListResourceTypes but not in local synced metadata."] + if item.detail is not None and item.detail.description: + evidence.append(_shorten_text(item.detail.description)) + elif item.detail is not None and item.detail.properties: + evidence.append("GetResourceType returned properties: {}.".format(", ".join(item.detail.properties))) + else: + evidence.append("No local RelatedTo/MainResourceType evidence is available.") + return tuple(evidence) + + +def _item_text(item: ResourceInventoryItem) -> str: + parts = [item.resource_type, item.name_en or "", item.name_zh or ""] + if item.detail is not None: + parts.append(item.detail.description or "") + for name, prop in item.detail.properties.items(): + parts.append(name) + parts.append(str(prop.get("Description") or "")) + return " ".join(parts).lower() + + +def _resource_identity_text(item: ResourceInventoryItem) -> str: + parts = [item.resource_type, item.name_en or "", item.name_zh or ""] + if item.detail is not None and item.detail.description: + parts.append(item.detail.description) + return " ".join(parts).lower() + + +def _looks_like_container_identity(item: ResourceInventoryItem) -> bool: + short_type = _short_resource_type(item.resource_type) + lowered = short_type.lower() + excluded_terms = ( + "access", + "account", + "addon", + "application", + "association", + "attachment", + "backup", + "binding", + "config", + "endpoint", + "entry", + "policy", + "rule", + "securityip", + "whitelist", + ) + if any(term in lowered for term in excluded_terms): + return False + exact_container_types = {"vpc", "vswitch", "securitygroup", "networkacl", "namespace", "workspace"} + if lowered in exact_container_types: + return True + if lowered.endswith(("cluster", "cluster2", "clusterv2", "namespace", "workspace")): + return True + name_text = _container_name_text(item) + return any(term in name_text for term in ("专有网络", "交换机", "命名空间")) + + +def _container_name_text(item: ResourceInventoryItem) -> str: + parts = [_short_resource_type(item.resource_type), item.name_en or "", item.name_zh or ""] + return " ".join(parts).lower() + + +def _short_resource_type(resource_type: str) -> str: + return resource_type.split("::")[-1] + + +def _container_role(short_type: str, text: str) -> str: + lowered = short_type.lower() + if "vswitch" in lowered or "vswitch" in text: + return "vswitch" + if "securitygroup" in lowered or "security group" in text: + return "security_group" + if "cluster" in lowered: + return "cluster" + if "workspace" in lowered: + return "workspace" + if "namespace" in lowered: + return "namespace" + return "vpc" if "vpc" in lowered or "vpc" in text else "container" + + +def _first_matching_property(properties: set[str], suffix: str) -> str: + return next((name for name in sorted(properties) if name.lower().endswith(suffix)), sorted(properties)[0]) + + +def _shorten_text(value: str, max_length: int = 180) -> str: + compact = " ".join(value.split()) + if len(compact) <= max_length: + return compact + return compact[: max_length - 3] + "..." diff --git a/src/iac_code/pipeline/engine/architecture_rule_drafts.py b/src/iac_code/pipeline/engine/architecture_rule_drafts.py new file mode 100644 index 00000000..2140591c --- /dev/null +++ b/src/iac_code/pipeline/engine/architecture_rule_drafts.py @@ -0,0 +1,579 @@ +"""LLM draft rule parsing, validation, review, and patch application.""" + +from __future__ import annotations + +import copy +import json +import re +from dataclasses import dataclass +from typing import Any + +from iac_code.pipeline.engine.architecture_rule_facts import ResourceRuleFact, ResourceRuleFactsBundle + +RuleLabel = str | dict[str, str] + +CLASSIFICATIONS = { + "core_node", + "container", + "attachment", + "bridge_attachment", + "attachment_edge", + "orchestration_action", + "concept_node", + "supplemental_relation", + "display", + "ignore", + "needs_review", +} + +SUPPORTED_PATCH_KEYS = { + "network_layer_types", + "containment_layer_types", + "fallback_related_properties", + "supplemental_related_properties", + "compact_hidden_short_types", + "compact_resource_labels", + "compact_attachment_marker_types", + "compact_child_attachments", + "compact_bridge_attachments", + "compact_attachment_edges", + "compact_orchestration_actions", + "compact_concept_nodes", +} + +CLASSIFICATION_PATCH_KEYS = { + "container": {"network_layer_types", "containment_layer_types"}, + "supplemental_relation": {"fallback_related_properties", "supplemental_related_properties"}, + "display": {"compact_hidden_short_types", "compact_resource_labels"}, + "attachment": {"compact_attachment_marker_types", "compact_child_attachments"}, + "bridge_attachment": {"compact_bridge_attachments"}, + "attachment_edge": {"compact_attachment_edges"}, + "orchestration_action": {"compact_orchestration_actions"}, + "concept_node": {"compact_concept_nodes"}, + "core_node": set(), + "ignore": set(), + "needs_review": set(), +} + +LIST_PATCH_KEYS = { + "network_layer_types", + "compact_hidden_short_types", + "compact_attachment_marker_types", + "compact_child_attachments", + "compact_bridge_attachments", + "compact_attachment_edges", + "compact_orchestration_actions", + "compact_concept_nodes", +} + +DICT_PATCH_KEYS = { + "containment_layer_types", + "fallback_related_properties", + "supplemental_related_properties", + "compact_resource_labels", +} + + +@dataclass(frozen=True) +class DraftRule: + resource_type: str + classification: str + target_resource_types: tuple[str, ...] + property_names: tuple[str, ...] + label: RuleLabel | None + edge_label: RuleLabel | None + confidence: float + evidence: tuple[str, ...] + suggested_architecture_rules_patch: dict[str, Any] + + @classmethod + def from_raw(cls, raw: Any) -> DraftRule | None: + if not isinstance(raw, dict): + return None + resource_type = raw.get("resource_type") + classification = raw.get("classification") + if not isinstance(resource_type, str) or not isinstance(classification, str): + return None + confidence = raw.get("confidence") + try: + normalized_confidence = float(confidence) + except (TypeError, ValueError): + normalized_confidence = 0.0 + patch = raw.get("suggested_architecture_rules_patch") + return cls( + resource_type=resource_type, + classification=classification, + target_resource_types=_string_tuple(raw.get("target_resource_types")), + property_names=_string_tuple(raw.get("property_names")), + label=_rule_label(raw.get("label")), + edge_label=_rule_label(raw.get("edge_label")), + confidence=max(0.0, min(1.0, normalized_confidence)), + evidence=_string_tuple(raw.get("evidence")), + suggested_architecture_rules_patch=patch if isinstance(patch, dict) else {}, + ) + + def to_dict(self) -> dict[str, Any]: + return { + "resource_type": self.resource_type, + "classification": self.classification, + "target_resource_types": list(self.target_resource_types), + "property_names": list(self.property_names), + "label": self.label, + "edge_label": self.edge_label, + "confidence": self.confidence, + "evidence": list(self.evidence), + "suggested_architecture_rules_patch": self.suggested_architecture_rules_patch, + } + + +@dataclass(frozen=True) +class DraftValidationResult: + draft: DraftRule + valid: bool + errors: tuple[str, ...] + + +@dataclass(frozen=True) +class DraftReviewDecision: + draft: DraftRule + accepted: bool + reasons: tuple[str, ...] + + def to_dict(self) -> dict[str, Any]: + return { + "accepted": self.accepted, + "reasons": list(self.reasons), + "draft": self.draft.to_dict(), + } + + +def parse_draft_rules_response(text: str) -> list[DraftRule]: + content = text.strip() + if content.startswith("```"): + content = re.sub(r"^```(?:json)?\s*", "", content) + content = re.sub(r"\s*```$", "", content) + try: + value = json.loads(content) + except json.JSONDecodeError: + match = re.search(r"\{.*\}", content, re.S) + if match is None: + raise ValueError("LLM output does not contain a JSON object") from None + value = json.loads(match.group(0)) + if isinstance(value, list): + raw_rules = value + elif isinstance(value, dict): + raw_rules = value.get("draft_rules") + else: + raise ValueError("LLM output JSON must be an object or draft rule list") + if not isinstance(raw_rules, list): + raise ValueError("LLM output JSON must contain draft_rules list") + drafts = [DraftRule.from_raw(item) for item in raw_rules] + return [draft for draft in drafts if draft is not None] + + +def validate_draft_rules( + drafts: list[DraftRule], + facts: ResourceRuleFactsBundle, +) -> list[DraftValidationResult]: + known_types = {fact.resource_type for fact in facts.resource_facts} + properties_by_type = { + fact.resource_type: set(fact.properties) | set(fact.related_properties) for fact in facts.resource_facts + } + results: list[DraftValidationResult] = [] + for draft in drafts: + errors: list[str] = [] + if draft.resource_type not in known_types: + errors.append(f"unknown resource type `{draft.resource_type}`") + if draft.classification not in CLASSIFICATIONS: + errors.append(f"unsupported classification `{draft.classification}`") + property_names = properties_by_type.get(draft.resource_type, set()) + for property_name in draft.property_names: + if property_name not in property_names: + errors.append(f"unknown property `{property_name}` for `{draft.resource_type}`") + for target in draft.target_resource_types: + if target not in known_types and not target.startswith("CONCEPT::"): + errors.append(f"unknown target resource type `{target}`") + errors.extend(_validate_patch_keys(draft, known_types, properties_by_type)) + if draft.classification not in {"core_node", "ignore", "needs_review"}: + if draft.classification == "attachment_edge": + if draft.edge_label is None: + errors.append("edge_label is required for attachment_edge draft rules") + elif draft.label is None: + errors.append("label is required for actionable draft rules") + if not draft.evidence: + errors.append("evidence is required for actionable draft rules") + results.append(DraftValidationResult(draft=draft, valid=not errors, errors=tuple(errors))) + return results + + +def review_valid_draft_rules( + validations: list[DraftValidationResult], + *, + minimum_confidence: float = 0.75, +) -> list[DraftReviewDecision]: + decisions: list[DraftReviewDecision] = [] + for validation in validations: + if not validation.valid: + decisions.append( + DraftReviewDecision( + draft=validation.draft, + accepted=False, + reasons=validation.errors, + ) + ) + continue + + draft = validation.draft + reasons: list[str] = [] + if draft.classification in {"ignore", "needs_review", "core_node"}: + reasons.append(f"classification `{draft.classification}` is not automatically applied") + if draft.confidence < minimum_confidence: + reasons.append( + "confidence {:.2f} is below automatic review threshold {:.2f}".format( + draft.confidence, minimum_confidence + ) + ) + if draft.classification in {"attachment", "bridge_attachment", "attachment_edge", "orchestration_action"}: + if _patch_uses_solid_business_edge(draft.suggested_architecture_rules_patch): + reasons.append("attachment/configuration rules must not use solid business traffic edges") + if draft.classification == "container" and _looks_like_security_or_whitelist(draft.resource_type): + reasons.append("security/whitelist resources are not accepted as containers by automatic review") + decisions.append( + DraftReviewDecision( + draft=draft, + accepted=not reasons, + reasons=tuple(reasons or ("schema validation and automatic review passed",)), + ) + ) + return decisions + + +def apply_reviewed_draft_patches( + raw_rules: dict[str, Any], + decisions: list[DraftReviewDecision], + *, + facts: ResourceRuleFactsBundle | None = None, +) -> dict[str, Any]: + updated = copy.deepcopy(raw_rules) + facts_by_type = {fact.resource_type: fact for fact in facts.resource_facts} if facts is not None else {} + for decision in decisions: + if not decision.accepted: + continue + for key, value in decision.draft.suggested_architecture_rules_patch.items(): + localized_value = _localize_patch_labels(value, facts_by_type, decision.draft.resource_type) + if key in LIST_PATCH_KEYS: + updated[key] = _merge_list(updated.get(key), localized_value) + elif key in DICT_PATCH_KEYS: + updated[key] = _merge_dict(updated.get(key), localized_value) + return updated + + +def render_draft_review_report_markdown(decisions: list[DraftReviewDecision]) -> str: + accepted_count = sum(1 for decision in decisions if decision.accepted) + rejected_count = len(decisions) - accepted_count + lines = [ + "# ROS 架构图 LLM Draft Rules Review", + "", + "## Summary", + "", + "| Metric | Count |", + "| --- | ---: |", + f"| Draft rules | {len(decisions)} |", + f"| Accepted | {accepted_count} |", + f"| Rejected | {rejected_count} |", + "", + "## By Classification", + "", + "| Classification | Drafts | Accepted | Rejected |", + "| --- | ---: | ---: | ---: |", + ] + for classification in sorted({decision.draft.classification for decision in decisions}): + class_decisions = [decision for decision in decisions if decision.draft.classification == classification] + class_accepted = sum(1 for decision in class_decisions if decision.accepted) + lines.append( + "| `{}` | {} | {} | {} |".format( + classification, + len(class_decisions), + class_accepted, + len(class_decisions) - class_accepted, + ) + ) + lines.extend( + [ + "", + "## Decisions", + "", + "| Resource type | Classification | Accepted | Reasons |", + "| --- | --- | --- | --- |", + ] + ) + for decision in sorted(decisions, key=lambda item: (item.draft.classification, item.draft.resource_type)): + reasons = "; ".join(decision.reasons).replace("|", "\\|") + lines.append( + "| `{}` | `{}` | `{}` | {} |".format( + decision.draft.resource_type, + decision.draft.classification, + "yes" if decision.accepted else "no", + reasons, + ) + ) + return "\n".join(lines).rstrip() + "\n" + + +def _validate_patch_keys( + draft: DraftRule, + known_types: set[str], + properties_by_type: dict[str, set[str]], +) -> list[str]: + errors: list[str] = [] + allowed_keys = CLASSIFICATION_PATCH_KEYS.get(draft.classification, set()) + for key, value in draft.suggested_architecture_rules_patch.items(): + if key not in SUPPORTED_PATCH_KEYS: + errors.append(f"unsupported patch key `{key}`") + continue + if key not in allowed_keys: + errors.append(f"patch key `{key}` is not allowed for `{draft.classification}`") + if key in LIST_PATCH_KEYS and not isinstance(value, list): + errors.append(f"patch key `{key}` must be a list") + if key in DICT_PATCH_KEYS and not isinstance(value, dict): + errors.append(f"patch key `{key}` must be an object") + errors.extend(_validate_patch_value(key, value, known_types, properties_by_type, draft.resource_type)) + if draft.classification not in {"core_node", "ignore", "needs_review"}: + if not draft.suggested_architecture_rules_patch: + errors.append("actionable draft rules require suggested_architecture_rules_patch") + return errors + + +def _validate_patch_value( + key: str, + value: Any, + known_types: set[str], + properties_by_type: dict[str, set[str]], + draft_resource_type: str, +) -> list[str]: + errors: list[str] = [] + if key in {"network_layer_types", "compact_hidden_short_types", "compact_attachment_marker_types"}: + for resource_type in _string_list(value): + if resource_type not in known_types and not resource_type.startswith("CONCEPT::"): + errors.append(f"unknown patch resource type `{resource_type}` in `{key}`") + return errors + if key == "containment_layer_types": + if not isinstance(value, dict): + return errors + for role, resource_types in value.items(): + if not isinstance(role, str): + errors.append(f"non-string containment role `{role}`") + for resource_type in _string_list(resource_types): + if resource_type not in known_types: + errors.append(f"unknown patch resource type `{resource_type}` in `{key}`") + return errors + if key == "compact_resource_labels": + if not isinstance(value, dict): + return errors + for resource_type in value: + if isinstance(resource_type, str) and resource_type not in known_types: + errors.append(f"unknown patch resource type `{resource_type}` in `{key}`") + return errors + if key == "fallback_related_properties": + if not isinstance(value, dict): + return errors + for targets in value.values(): + for resource_type in _string_list(targets): + if resource_type not in known_types: + errors.append(f"unknown patch resource type `{resource_type}` in `{key}`") + return errors + if key == "supplemental_related_properties": + if not isinstance(value, dict): + return errors + for resource_type, properties in value.items(): + if not isinstance(resource_type, str): + continue + if resource_type not in known_types: + errors.append(f"unknown patch resource type `{resource_type}` in `{key}`") + if not isinstance(properties, dict): + continue + for property_name, targets in properties.items(): + if isinstance(property_name, str): + _validate_property_name( + property_name, + {resource_type}, + properties_by_type, + errors, + ) + for target in _string_list(targets): + if target not in known_types: + errors.append(f"unknown patch resource type `{target}` in `{key}`") + return errors + if key in LIST_PATCH_KEYS: + for item in value if isinstance(value, list) else []: + if isinstance(item, dict): + errors.extend( + _validate_patch_rule_object(item, known_types, properties_by_type, draft_resource_type, key) + ) + return errors + + +def _validate_patch_rule_object( + item: dict[str, Any], + known_types: set[str], + properties_by_type: dict[str, set[str]], + draft_resource_type: str, + patch_key: str, +) -> list[str]: + errors: list[str] = [] + relevant_resource_types = {draft_resource_type} + if patch_key == "compact_bridge_attachments" and not _string_list(item.get("via_resource_types")): + errors.append("compact_bridge_attachments require non-empty via_resource_types") + for field in ("resource_types", "via_resource_types", "source_types", "target_types", "marker_types"): + for resource_type in _string_list(item.get(field)): + if resource_type not in known_types and not resource_type.startswith("CONCEPT::"): + errors.append(f"unknown patch resource type `{resource_type}` in `{patch_key}.{field}`") + else: + relevant_resource_types.add(resource_type) + if isinstance(item.get("resource_type"), str): + resource_type = item["resource_type"] + if resource_type not in known_types and not resource_type.startswith("CONCEPT::"): + errors.append(f"unknown patch resource type `{resource_type}` in `{patch_key}.resource_type`") + else: + relevant_resource_types.add(resource_type) + + property_fields = ( + "source_properties", + "target_properties", + "marker_properties", + "command_properties", + "evidence_properties", + "via_source_properties", + "via_target_properties", + ) + for field in property_fields: + for property_name in _string_list(item.get(field)): + _validate_property_name(property_name, relevant_resource_types, properties_by_type, errors) + for field in ("controller_property", "source_property"): + property_name = item.get(field) + if isinstance(property_name, str): + _validate_property_name(property_name, relevant_resource_types, properties_by_type, errors) + return errors + + +def _localize_patch_labels(value: Any, facts_by_type: dict[str, ResourceRuleFact], draft_resource_type: str) -> Any: + if isinstance(value, list): + return [_localize_patch_labels(item, facts_by_type, draft_resource_type) for item in value] + if not isinstance(value, dict): + return copy.deepcopy(value) + result = copy.deepcopy(value) + for key in ("label", "edge_label"): + raw_label = result.get(key) + if isinstance(raw_label, str) and raw_label: + result[key] = _localized_label(raw_label, facts_by_type.get(draft_resource_type)) + for key, nested in list(result.items()): + if key in {"label", "edge_label"}: + continue + if isinstance(nested, (dict, list)): + result[key] = _localize_patch_labels(nested, facts_by_type, draft_resource_type) + return result + + +def _localized_label(label: str, fact: ResourceRuleFact | None) -> dict[str, str]: + zh = label + if fact is not None and isinstance(fact.name.get("zh"), str) and fact.name["zh"]: + zh = fact.name["zh"] + return {"zh": zh, "en": label} + + +def _validate_property_name( + property_name: str, + resource_types: set[str], + properties_by_type: dict[str, set[str]], + errors: list[str], +) -> None: + if any(property_name in properties_by_type.get(resource_type, set()) for resource_type in resource_types): + return + resources = ", ".join(sorted(resource_types)) + errors.append(f"unknown patch property `{property_name}` for `{resources}`") + + +def _string_list(raw: Any) -> list[str]: + if not isinstance(raw, list): + return [] + return [item for item in raw if isinstance(item, str)] + + +def _patch_uses_solid_business_edge(patch: dict[str, Any]) -> bool: + for key in ("compact_attachment_edges", "compact_relation_folds"): + values = patch.get(key) + if not isinstance(values, list): + continue + for item in values: + if isinstance(item, dict) and item.get("edge_style") == "solid_arrow": + return True + return False + + +def _looks_like_security_or_whitelist(resource_type: str) -> bool: + lowered = resource_type.lower() + return any(token in lowered for token in ("securityip", "whitelist", "securitygroup", "accessrule")) + + +def _merge_list(current: Any, patch: Any) -> list[Any]: + values = list(current) if isinstance(current, list) else [] + additions = patch if isinstance(patch, list) else [] + seen = {_stable_json(value) for value in values} + semantic_seen = {_semantic_rule_key(value) for value in values} + for item in additions: + key = _stable_json(item) + semantic_key = _semantic_rule_key(item) + if key in seen or (semantic_key is not None and semantic_key in semantic_seen): + continue + seen.add(key) + semantic_seen.add(semantic_key) + values.append(copy.deepcopy(item)) + return values + + +def _merge_dict(current: Any, patch: Any) -> dict[str, Any]: + values = copy.deepcopy(current) if isinstance(current, dict) else {} + if not isinstance(patch, dict): + return values + for key, patch_value in patch.items(): + if not isinstance(key, str): + continue + current_value = values.get(key) + if isinstance(current_value, list) and isinstance(patch_value, list): + values[key] = _merge_list(current_value, patch_value) + elif isinstance(current_value, dict) and isinstance(patch_value, dict): + values[key] = _merge_dict(current_value, patch_value) + else: + values[key] = copy.deepcopy(patch_value) + return values + + +def _stable_json(value: Any) -> str: + return json.dumps(value, ensure_ascii=False, sort_keys=True) + + +def _semantic_rule_key(value: Any) -> tuple[str, tuple[str, ...]] | None: + if not isinstance(value, dict): + return None + for key in ("resource_types", "via_resource_types"): + raw = value.get(key) + if isinstance(raw, list) and raw and all(isinstance(item, str) for item in raw): + return key, tuple(sorted(raw)) + return None + + +def _string_tuple(raw: Any) -> tuple[str, ...]: + if not isinstance(raw, list): + return () + return tuple(item for item in raw if isinstance(item, str)) + + +def _rule_label(raw: Any) -> RuleLabel | None: + if raw is None: + return None + if isinstance(raw, str) and raw: + return raw + if isinstance(raw, dict): + labels = {key: value for key, value in raw.items() if isinstance(key, str) and isinstance(value, str)} + return labels or None + return None diff --git a/src/iac_code/pipeline/engine/architecture_rule_facts.py b/src/iac_code/pipeline/engine/architecture_rule_facts.py new file mode 100644 index 00000000..aa20f45b --- /dev/null +++ b/src/iac_code/pipeline/engine/architecture_rule_facts.py @@ -0,0 +1,241 @@ +"""LLM input facts and deterministic rule signals for ROS architecture rules.""" + +from __future__ import annotations + +from dataclasses import dataclass +from typing import Any + +from iac_code.pipeline.engine.architecture_resource_inventory import ( + ResourceInventoryItem, + ResourceInventorySnapshot, +) +from iac_code.pipeline.engine.architecture_rule_candidates import RuleCandidate, extract_rule_candidates +from iac_code.pipeline.engine.architecture_rules import ArchitectureRules + + +@dataclass(frozen=True) +class ResourceRuleFact: + resource_type: str + product_code: str + source_state: str + name: dict[str, str | None] + description: str | None + category_code: str | None + properties: dict[str, dict[str, Any]] + related_properties: dict[str, list[str]] + main_resource_type: dict[str, str] | None + fixed_rule_hits: tuple[str, ...] + + def to_dict(self) -> dict[str, Any]: + return { + "resource_type": self.resource_type, + "product_code": self.product_code, + "source_state": self.source_state, + "name": self.name, + "description": self.description, + "category_code": self.category_code, + "properties": self.properties, + "related_properties": self.related_properties, + "main_resource_type": self.main_resource_type, + "fixed_rule_hits": list(self.fixed_rule_hits), + } + + +@dataclass(frozen=True) +class RuleSignal: + category: str + resource_type: str + product_code: str + property_name: str | None + target_resource_types: tuple[str, ...] + confidence: str + evidence: tuple[str, ...] + suggested_patch: dict[str, Any] + + @classmethod + def from_candidate(cls, candidate: RuleCandidate) -> RuleSignal: + return cls( + category=candidate.category, + resource_type=candidate.resource_type, + product_code=candidate.product_code, + property_name=candidate.property_name, + target_resource_types=candidate.target_resource_types, + confidence=candidate.confidence, + evidence=candidate.evidence, + suggested_patch=candidate.suggested_config, + ) + + def to_dict(self) -> dict[str, Any]: + return { + "category": self.category, + "resource_type": self.resource_type, + "product_code": self.product_code, + "property_name": self.property_name, + "target_resource_types": list(self.target_resource_types), + "confidence": self.confidence, + "evidence": list(self.evidence), + "suggested_patch": self.suggested_patch, + } + + +@dataclass(frozen=True) +class ResourceRuleFactsBundle: + resource_facts: tuple[ResourceRuleFact, ...] + rule_signals: tuple[RuleSignal, ...] + api_resource_type_count: int + local_resource_type_count: int + api_only_resource_types: tuple[str, ...] + local_only_resource_types: tuple[str, ...] + fetch_errors: dict[str, str] + + def to_dict(self) -> dict[str, Any]: + return { + "summary": { + "api_resource_types": self.api_resource_type_count, + "local_resource_types": self.local_resource_type_count, + "api_only_resource_types": len(self.api_only_resource_types), + "local_only_resource_types": len(self.local_only_resource_types), + "fetch_errors": len(self.fetch_errors), + "resource_facts": len(self.resource_facts), + "rule_signals": len(self.rule_signals), + }, + "resource_facts": [fact.to_dict() for fact in self.resource_facts], + "rule_signals": [signal.to_dict() for signal in self.rule_signals], + } + + +def build_resource_rule_facts( + snapshot: ResourceInventorySnapshot, + rules: ArchitectureRules | None = None, +) -> ResourceRuleFactsBundle: + """Build deterministic LLM facts and signals without making final rule decisions.""" + + rules = rules or ArchitectureRules.load_default() + facts = tuple( + _build_resource_fact(snapshot.items[resource_type], rules) + for resource_type in snapshot.api_resource_types + if resource_type in snapshot.items + ) + signals = tuple(RuleSignal.from_candidate(candidate) for candidate in extract_rule_candidates(snapshot)) + return ResourceRuleFactsBundle( + resource_facts=facts, + rule_signals=signals, + api_resource_type_count=len(snapshot.api_resource_types), + local_resource_type_count=len(snapshot.local_resource_types), + api_only_resource_types=snapshot.api_only_resource_types, + local_only_resource_types=snapshot.local_only_resource_types, + fetch_errors=snapshot.fetch_errors, + ) + + +def render_resource_rule_facts_markdown(bundle: ResourceRuleFactsBundle) -> str: + payload = bundle.to_dict() + lines = [ + "# ROS 架构图 Resource Facts / Rule Signals", + "", + "## Summary", + "", + "| Metric | Count |", + "| --- | ---: |", + ] + for key, value in payload["summary"].items(): + lines.append(f"| `{key}` | {value} |") + lines.extend(["", "## Rule Signals", ""]) + + signals_by_category: dict[str, list[RuleSignal]] = {} + for signal in bundle.rule_signals: + signals_by_category.setdefault(signal.category, []).append(signal) + for category in sorted(signals_by_category): + lines.extend( + [ + f"### `{category}`", + "", + "| Resource type | Confidence | Targets | Evidence |", + "| --- | --- | --- | --- |", + ] + ) + for signal in sorted(signals_by_category[category], key=lambda item: item.resource_type): + targets = ", ".join(f"`{target}`" for target in signal.target_resource_types) or "-" + evidence = "; ".join(signal.evidence[:2]).replace("|", "\\|") + lines.append(f"| `{signal.resource_type}` | `{signal.confidence}` | {targets} | {evidence} |") + lines.append("") + return "\n".join(lines).rstrip() + "\n" + + +def _build_resource_fact(item: ResourceInventoryItem, rules: ArchitectureRules) -> ResourceRuleFact: + return ResourceRuleFact( + resource_type=item.resource_type, + product_code=item.product_code, + source_state=item.source_state, + name={"zh": item.name_zh, "en": item.name_en}, + description=item.detail.description if item.detail is not None else None, + category_code=item.category_code, + properties=_property_facts(item), + related_properties=_related_properties(item), + main_resource_type=_main_resource_type(item), + fixed_rule_hits=tuple(_fixed_rule_hits(item.resource_type, rules)), + ) + + +def _property_facts(item: ResourceInventoryItem) -> dict[str, dict[str, Any]]: + property_names = set() + if item.detail is not None: + property_names.update(item.detail.properties) + if item.meta is not None: + property_names.update(prop.name for prop in item.meta.related_properties) + if item.meta.main_resource_type is not None: + property_names.add(item.meta.main_resource_type.ref_property) + + result: dict[str, dict[str, Any]] = {} + detail_properties = item.detail.properties if item.detail is not None else {} + meta_properties = item.meta.related_properties_by_name if item.meta is not None else {} + for name in sorted(property_names): + raw = detail_properties.get(name, {}) + meta = meta_properties.get(name) + result[name] = { + "type": raw.get("Type") or (meta.value_type if meta is not None else None), + "required": raw.get("Required") if isinstance(raw.get("Required"), bool) else None, + "description": raw.get("Description") if isinstance(raw.get("Description"), str) else None, + "related_targets": list(meta.targets) if meta is not None else [], + } + return result + + +def _related_properties(item: ResourceInventoryItem) -> dict[str, list[str]]: + if item.meta is None: + return {} + return {prop.name: list(prop.targets) for prop in item.meta.related_properties} + + +def _main_resource_type(item: ResourceInventoryItem) -> dict[str, str] | None: + if item.meta is None or item.meta.main_resource_type is None: + return None + return { + "resource_type": item.meta.main_resource_type.resource_type, + "ref_property": item.meta.main_resource_type.ref_property, + } + + +def _fixed_rule_hits(resource_type: str, rules: ArchitectureRules) -> list[str]: + hits: list[str] = [] + if resource_type in rules.network_layer_types: + hits.append("network_layer_types") + for role, types in rules.containment_layer_types.items(): + if resource_type in types: + hits.append(f"containment_layer_types.{role}") + if resource_type in rules.compact_attachment_marker_types: + hits.append("compact_attachment_marker_types") + if resource_type in rules.supplemental_related_properties: + hits.append("supplemental_related_properties") + if resource_type in rules.compact_orchestration_action_types: + hits.append("compact_orchestration_actions") + for key, collections in ( + ("compact_child_attachments", rules.compact_child_attachments), + ("compact_bridge_attachments", rules.compact_bridge_attachments), + ("compact_attachment_edges", rules.compact_attachment_edges), + ): + if any(resource_type in rule.resource_types for rule in collections): + hits.append(key) + if any(resource_type in node.via_resource_types for node in rules.compact_concept_nodes): + hits.append("compact_concept_nodes") + return hits diff --git a/src/iac_code/pipeline/engine/architecture_rules.json b/src/iac_code/pipeline/engine/architecture_rules.json new file mode 100644 index 00000000..d6dc9574 --- /dev/null +++ b/src/iac_code/pipeline/engine/architecture_rules.json @@ -0,0 +1,2606 @@ +{ + "attachment_label_prefix": "+ ", + "compact_attachment_edges": [ + { + "edge_label": { + "en": "public bandwidth", + "zh": "公网带宽" + }, + "edge_style": "dotted_open", + "marker_properties": [ + "Eips" + ], + "marker_types": [ + "ALIYUN::VPC::EIP" + ], + "resource_types": [ + "ALIYUN::VPC::CommonBandwidthPackageIp" + ], + "source_properties": [ + "BandwidthPackageId" + ], + "source_types": [ + "ALIYUN::VPC::CommonBandwidthPackage" + ] + }, + { + "edge_label": { + "en": "Add Replica Pair", + "zh": "添加复制对" + }, + "edge_style": "dotted_open", + "marker_properties": [ + "ReplicaPairId" + ], + "marker_types": [ + "ALIYUN::EBS::DiskReplicaPair" + ], + "resource_types": [ + "ALIYUN::EBS::DiskReplicaPairAddition" + ], + "source_properties": [ + "ReplicaGroupId" + ], + "source_types": [ + "ALIYUN::EBS::DiskReplicaGroup" + ] + } + ], + "compact_attachment_marker_types": [ + "ALIYUN::ECS::NetworkInterface", + "ALIYUN::VPC::AnycastEIP", + "ALIYUN::VPC::EIP", + "ALIYUN::VPC::HaVip" + ], + "compact_bridge_attachments": [ + { + "label": { + "en": "NAS permission group", + "zh": "NAS权限组" + }, + "resource_types": [ + "ALIYUN::NAS::AccessGroup" + ], + "target_types": [ + "ALIYUN::NAS::FileSystem" + ], + "via_resource_types": [ + "ALIYUN::NAS::MountTarget" + ], + "via_source_properties": [ + "AccessGroupName" + ], + "via_target_properties": [ + "FileSystemId" + ] + }, + { + "label": { + "en": "NAS permission rule", + "zh": "NAS权限规则" + }, + "resource_types": [ + "ALIYUN::NAS::AccessRule" + ], + "source_properties": [ + "AccessGroupName" + ], + "target_types": [ + "ALIYUN::NAS::FileSystem" + ], + "via_resource_types": [ + "ALIYUN::NAS::MountTarget" + ], + "via_source_properties": [ + "AccessGroupName" + ], + "via_target_properties": [ + "FileSystemId" + ] + }, + { + "label": { + "en": "Associate ACL", + "zh": "访问控制绑定" + }, + "resource_types": [ + "ALIYUN::SAG::ACL" + ], + "source_properties": [], + "target_types": [ + "ALIYUN::SAG::SmartAccessGateway" + ], + "via_resource_types": [ + "ALIYUN::SAG::ACLAssociation" + ], + "via_source_properties": [ + "AclId" + ], + "via_target_properties": [ + "SmartAGId" + ] + }, + { + "label": { + "en": "Attach QoS Policy", + "zh": "QoS策略实例绑定" + }, + "resource_types": [ + "ALIYUN::SAG::Qos" + ], + "source_properties": [], + "target_types": [ + "ALIYUN::SAG::SmartAccessGateway" + ], + "via_resource_types": [ + "ALIYUN::SAG::QosAssociation" + ], + "via_source_properties": [ + "QosId" + ], + "via_target_properties": [ + "SmartAGId" + ] + }, + { + "label": { + "en": "Backend Server", + "zh": "添加后端服务器" + }, + "resource_types": [ + "ALIYUN::ECS::Instance", + "ALIYUN::ECS::InstanceGroup" + ], + "source_properties": [], + "target_types": [ + "ALIYUN::SLB::LoadBalancer" + ], + "via_resource_types": [ + "ALIYUN::SLB::BackendServerAttachment" + ], + "via_source_properties": [ + "ServerId" + ], + "via_target_properties": [ + "LoadBalancerId" + ] + }, + { + "label": { + "en": "Bandwidth Plan", + "zh": "带宽包" + }, + "resource_types": [ + "ALIYUN::ECD::NetworkPackage" + ], + "source_properties": [], + "target_types": [ + "ALIYUN::ECD::SimpleOfficeSite" + ], + "via_resource_types": [ + "ALIYUN::ECD::NetworkPackageAssociation" + ], + "via_source_properties": [ + "NetworkPackageId" + ], + "via_target_properties": [ + "OfficeSiteId" + ] + }, + { + "label": { + "en": "Bind CCN", + "zh": "绑定CCN" + }, + "resource_types": [ + "ALIYUN::SAG::SmartAccessGateway" + ], + "source_properties": [], + "target_types": [ + "ALIYUN::SAG::CloudConnectNetwork" + ], + "via_resource_types": [ + "ALIYUN::SAG::SmartAccessGatewayBinding" + ], + "via_source_properties": [ + "SmartAGId" + ], + "via_target_properties": [ + "CcnId" + ] + }, + { + "label": { + "en": "Associate DHCP Options Set", + "zh": "关联DHCP选项集" + }, + "resource_types": [ + "ALIYUN::VPC::DhcpOptionsSet" + ], + "source_properties": [], + "target_types": [ + "ALIYUN::ECS::VPC" + ], + "via_resource_types": [ + "ALIYUN::VPC::DhcpOptionsSetAttachment" + ], + "via_source_properties": [ + "DhcpOptionsSetId" + ], + "via_target_properties": [ + "VpcId" + ] + }, + { + "label": { + "en": "Bind Router Interfaces", + "zh": "绑定互联路由器接口" + }, + "resource_types": [ + "ALIYUN::VPC::RouterInterface" + ], + "source_properties": [], + "target_types": [ + "ALIYUN::VPC::RouterInterface" + ], + "via_resource_types": [ + "ALIYUN::VPC::PeeringRouterInterfaceBinding" + ], + "via_source_properties": [ + "RouterInterfaceId" + ], + "via_target_properties": [ + "OppositeInterfaceId" + ] + }, + { + "label": { + "en": "ALB server group", + "zh": "ALB服务器组" + }, + "resource_types": [ + "ALIYUN::ALB::ServerGroup" + ], + "source_properties": [], + "target_types": [ + "ALIYUN::ALB::LoadBalancer" + ], + "via_resource_types": [ + "ALIYUN::ALB::Listener" + ], + "via_source_properties": [ + "ServerGroupId" + ], + "via_target_properties": [ + "LoadBalancerId" + ] + }, + { + "label": { + "en": "NLB server group", + "zh": "NLB服务器组" + }, + "resource_types": [ + "ALIYUN::NLB::ServerGroup" + ], + "source_properties": [], + "target_types": [ + "ALIYUN::NLB::LoadBalancer" + ], + "via_resource_types": [ + "ALIYUN::NLB::Listener" + ], + "via_source_properties": [ + "ServerGroupId" + ], + "via_target_properties": [ + "LoadBalancerId" + ] + }, + { + "label": { + "en": "Shared bandwidth package", + "zh": "共享带宽包" + }, + "resource_types": [ + "ALIYUN::VPC::CommonBandwidthPackage" + ], + "source_properties": [], + "target_self": true, + "target_types": [ + "ALIYUN::NLB::LoadBalancer" + ], + "via_resource_types": [ + "ALIYUN::NLB::LoadBalancer" + ], + "via_source_properties": [ + "BandwidthPackageId" + ], + "via_target_properties": [] + } + ], + "compact_child_attachments": [ + { + "label": { + "en": "SNAT entry", + "zh": "SNAT条目" + }, + "resource_types": [ + "ALIYUN::VPC::SnatEntry" + ], + "target_properties": [ + "SnatTableId" + ], + "target_types": [ + "ALIYUN::VPC::NatGateway" + ] + }, + { + "label": { + "en": "SNAT entry", + "zh": "SNAT条目" + }, + "resource_types": [ + "ALIYUN::ECS::SNatEntry" + ], + "target_properties": [ + "SNatTableId" + ], + "target_types": [ + "ALIYUN::VPC::NatGateway" + ] + }, + { + "label": { + "en": "DNAT entry", + "zh": "DNAT条目" + }, + "resource_types": [ + "ALIYUN::VPC::ForwardEntry", + "ALIYUN::ECS::ForwardEntry" + ], + "target_properties": [ + "ForwardTableId" + ], + "target_types": [ + "ALIYUN::VPC::NatGateway" + ] + }, + { + "label": { + "en": "FULLNAT entry", + "zh": "FULLNAT条目" + }, + "resource_types": [ + "ALIYUN::VPC::FullNatEntry" + ], + "target_properties": [ + "FullNatTableId" + ], + "target_types": [ + "ALIYUN::VPC::NatGateway" + ] + }, + { + "label": { + "en": "NAT IP", + "zh": "NAT IP地址" + }, + "resource_types": [ + "ALIYUN::VPC::NatIp" + ], + "target_properties": [ + "NatGatewayId" + ], + "target_types": [ + "ALIYUN::VPC::NatGateway" + ] + }, + { + "label": { + "en": "NAT IP CIDR", + "zh": "NAT IP地址段" + }, + "resource_types": [ + "ALIYUN::VPC::NatIpCidr" + ], + "target_properties": [ + "NatGatewayId" + ], + "target_types": [ + "ALIYUN::VPC::NatGateway" + ] + }, + { + "label": { + "en": "DB node", + "zh": "数据库节点" + }, + "resource_types": [ + "ALIYUN::POLARDB::DBInstance", + "ALIYUN::POLARDB::DBNodes" + ], + "target_properties": [ + "DBClusterId" + ], + "target_types": [ + "ALIYUN::POLARDB::DBCluster" + ] + }, + { + "label": { + "en": "Account privilege", + "zh": "账号权限" + }, + "resource_types": [ + "ALIYUN::POLARDB::AccountPrivilege" + ], + "target_properties": [ + "DBClusterId" + ], + "target_types": [ + "ALIYUN::POLARDB::DBCluster" + ] + }, + { + "label": { + "en": "Access whitelist", + "zh": "访问白名单" + }, + "resource_types": [ + "ALIYUN::POLARDB::DBClusterAccessWhiteList" + ], + "target_properties": [ + "DBClusterId" + ], + "target_types": [ + "ALIYUN::POLARDB::DBCluster" + ] + }, + { + "label": { + "en": "Database", + "zh": "数据库" + }, + "resource_types": [ + "ALIYUN::RDS::Database" + ], + "target_properties": [ + "DBInstanceId" + ], + "target_types": [ + "ALIYUN::RDS::DBInstance", + "ALIYUN::RDS::PrepayDBInstance" + ] + }, + { + "label": { + "en": "DB account", + "zh": "数据库账号" + }, + "resource_types": [ + "ALIYUN::RDS::Account" + ], + "target_properties": [ + "DBInstanceId" + ], + "target_types": [ + "ALIYUN::RDS::DBInstance", + "ALIYUN::RDS::PrepayDBInstance" + ] + }, + { + "label": { + "en": "Account privilege", + "zh": "账号权限" + }, + "resource_types": [ + "ALIYUN::RDS::AccountPrivilege" + ], + "target_properties": [ + "DBInstanceId" + ], + "target_types": [ + "ALIYUN::RDS::DBInstance", + "ALIYUN::RDS::PrepayDBInstance" + ] + }, + { + "label": { + "en": "Access whitelist", + "zh": "访问白名单" + }, + "resource_types": [ + "ALIYUN::RDS::DBInstanceSecurityIps" + ], + "target_properties": [ + "DBInstanceId" + ], + "target_types": [ + "ALIYUN::RDS::DBInstance", + "ALIYUN::RDS::PrepayDBInstance" + ] + }, + { + "label": { + "en": "Read-only instance", + "zh": "只读实例" + }, + "resource_types": [ + "ALIYUN::RDS::ReadOnlyDBInstance" + ], + "target_properties": [ + "DBInstanceId" + ], + "target_types": [ + "ALIYUN::RDS::DBInstance", + "ALIYUN::RDS::PrepayDBInstance" + ] + }, + { + "label": { + "en": "Public endpoint", + "zh": "外网连接地址" + }, + "resource_types": [ + "ALIYUN::RDS::Connection" + ], + "target_properties": [ + "DBInstanceId" + ], + "target_types": [ + "ALIYUN::RDS::DBInstance", + "ALIYUN::RDS::PrepayDBInstance" + ] + }, + { + "label": { + "en": "PostgreSQL extension", + "zh": "PostgreSQL扩展" + }, + "resource_types": [ + "ALIYUN::RDS::PostgresExtensions" + ], + "target_properties": [ + "DBInstanceId" + ], + "target_types": [ + "ALIYUN::RDS::DBInstance", + "ALIYUN::RDS::PrepayDBInstance" + ] + }, + { + "label": { + "en": "ACK application config", + "zh": "ACK应用配置" + }, + "resource_types": [ + "ALIYUN::CS::ClusterApplication" + ], + "target_properties": [ + "ClusterId" + ], + "target_types": [ + "ALIYUN::CS::ManagedKubernetesCluster", + "ALIYUN::CS::KubernetesCluster", + "ALIYUN::CS::ManagedEdgeKubernetesCluster", + "ALIYUN::CS::ServerlessKubernetesCluster" + ] + }, + { + "label": { + "en": "Logstore", + "zh": "日志库" + }, + "resource_types": [ + "ALIYUN::SLS::Logstore" + ], + "target_properties": [ + "ProjectName" + ], + "target_types": [ + "ALIYUN::SLS::Project" + ] + }, + { + "label": { + "en": "AccessKey", + "zh": "AccessKey" + }, + "resource_types": [ + "ALIYUN::RAM::AccessKey" + ], + "target_properties": [ + "UserName" + ], + "target_types": [ + "ALIYUN::RAM::User" + ] + }, + { + "label": { + "en": "User group", + "zh": "用户组" + }, + "resource_types": [ + "ALIYUN::RAM::UserToGroupAddition" + ], + "target_properties": [ + "Users", + "GroupName" + ], + "target_types": [ + "ALIYUN::RAM::User", + "ALIYUN::RAM::Group" + ] + }, + { + "label": { + "en": "NAS mount target", + "zh": "NAS挂载点" + }, + "resource_types": [ + "ALIYUN::NAS::MountTarget" + ], + "target_properties": [ + "FileSystemId" + ], + "target_types": [ + "ALIYUN::NAS::FileSystem" + ] + }, + { + "label": { + "en": "Shared bandwidth IP", + "zh": "共享带宽IP" + }, + "resource_types": [ + "ALIYUN::VPC::CommonBandwidthPackageIp" + ], + "target_properties": [ + "BandwidthPackageId" + ], + "target_types": [ + "ALIYUN::VPC::CommonBandwidthPackage" + ] + }, + { + "label": { + "en": "Route", + "zh": "路由" + }, + "resource_types": [ + "ALIYUN::ECS::Route" + ], + "target_properties": [ + "RouteTableId" + ], + "target_types": [ + "ALIYUN::ECS::VPC" + ] + }, + { + "label": { + "en": "VPC route table", + "zh": "VPC路由表" + }, + "resource_types": [ + "ALIYUN::VPC::RouteTable" + ], + "target_properties": [ + "VpcId" + ], + "target_types": [ + "ALIYUN::ECS::VPC" + ] + }, + { + "label": { + "en": "Route", + "zh": "路由" + }, + "resource_types": [ + "ALIYUN::ECS::Route" + ], + "target_properties": [ + "RouteTableId" + ], + "target_types": [ + "ALIYUN::VPC::RouteTable" + ] + }, + { + "label": { + "en": "CEN route table", + "zh": "CEN路由表" + }, + "resource_types": [ + "ALIYUN::CEN::TransitRouterRouteTable" + ], + "target_properties": [ + "TransitRouterId" + ], + "target_types": [ + "ALIYUN::CEN::TransitRouter" + ] + }, + { + "label": { + "en": "Route Table Association", + "zh": "关联CEN转发关系" + }, + "resource_types": [ + "ALIYUN::CEN::TransitRouterRouteTableAssociation" + ], + "target_properties": [ + "TransitRouterRouteTableId" + ], + "target_types": [ + "ALIYUN::CEN::TransitRouterRouteTable", + "ALIYUN::CEN::TransitRouter" + ] + }, + { + "label": { + "en": "Route Learning", + "zh": "路由学习" + }, + "resource_types": [ + "ALIYUN::CEN::TransitRouterRouteTablePropagation" + ], + "target_properties": [ + "TransitRouterRouteTableId" + ], + "target_types": [ + "ALIYUN::CEN::TransitRouterRouteTable", + "ALIYUN::CEN::TransitRouter" + ] + }, + { + "label": { + "en": "Disk Attachment", + "zh": "绑定云盘" + }, + "resource_types": [ + "ALIYUN::ECS::DiskAttachment" + ], + "target_properties": [ + "InstanceId" + ], + "target_types": [ + "ALIYUN::ECS::Instance", + "ALIYUN::ECS::InstanceGroup" + ] + }, + { + "label": { + "en": "ENI Attachment", + "zh": "绑定网卡" + }, + "resource_types": [ + "ALIYUN::ECS::NetworkInterfaceAttachment" + ], + "target_properties": [ + "InstanceId" + ], + "target_types": [ + "ALIYUN::ECS::Instance", + "ALIYUN::ECS::InstanceGroup" + ] + }, + { + "label": { + "en": "binds to", + "zh": "绑定密钥对" + }, + "resource_types": [ + "ALIYUN::ECS::SSHKeyPairAttachment" + ], + "target_properties": [ + "InstanceIds" + ], + "target_types": [ + "ALIYUN::ECS::Instance", + "ALIYUN::ECS::InstanceGroup" + ] + }, + { + "label": { + "en": "Disk attachment", + "zh": "挂载磁盘" + }, + "resource_types": [ + "ALIYUN::ENS::DiskInstanceAttachment" + ], + "target_properties": [ + "InstanceId" + ], + "target_types": [ + "ALIYUN::ENS::Instance" + ] + }, + { + "label": { + "en": "Security Group", + "zh": "安全组" + }, + "resource_types": [ + "ALIYUN::ENS::InstanceSecurityGroupAttachment" + ], + "target_properties": [ + "InstanceId" + ], + "target_types": [ + "ALIYUN::ENS::Instance" + ] + }, + { + "label": { + "en": "Networks", + "zh": "网络" + }, + "resource_types": [ + "ALIYUN::ENS::NetworkAclAssociation" + ], + "target_properties": [ + "NetworkAclId" + ], + "target_types": [ + "ALIYUN::ENS::NetworkAcl" + ] + }, + { + "label": { + "en": "ECI Config", + "zh": "ECI伸缩配置" + }, + "resource_types": [ + "ALIYUN::ESS::EciScalingConfiguration" + ], + "target_properties": [ + "ScalingGroupId" + ], + "target_types": [ + "ALIYUN::ESS::ScalingGroup" + ] + }, + { + "label": { + "en": "ACLs", + "zh": "ACL访问控制列表" + }, + "resource_types": [ + "ALIYUN::GA::AclsListenerAssociation" + ], + "target_properties": [ + "ListenerId" + ], + "target_types": [ + "ALIYUN::GA::Listener" + ] + }, + { + "label": { + "en": "Bandwidth Package", + "zh": "绑定全球加速带宽包" + }, + "resource_types": [ + "ALIYUN::GA::BandwidthPackageAcceleratorAddition" + ], + "target_properties": [ + "AcceleratorId" + ], + "target_types": [ + "ALIYUN::GA::Accelerator" + ] + }, + { + "label": { + "en": "Service Resources", + "zh": "添加服务资源" + }, + "resource_types": [ + "ALIYUN::PrivateLink::VpcEndpointServiceAttachment" + ], + "target_properties": [ + "ServiceId" + ], + "target_types": [ + "ALIYUN::PrivateLink::VpcEndpointService" + ] + }, + { + "label": { + "en": "Targets", + "zh": "目标" + }, + "resource_types": [ + "ALIYUN::ResourceManager::ControlPolicyAttachment" + ], + "target_properties": [ + "PolicyId" + ], + "target_types": [ + "ALIYUN::ResourceManager::ControlPolicy" + ] + }, + { + "label": { + "en": "Targets & Resources", + "zh": "目标与资源" + }, + "resource_types": [ + "ALIYUN::ResourceManager::ResourceShareAssociation" + ], + "target_properties": [ + "ResourceShareId" + ], + "target_types": [ + "ALIYUN::ResourceManager::ResourceShare" + ] + }, + { + "label": { + "en": "Listener", + "zh": "SLB监听" + }, + "resource_types": [ + "ALIYUN::SLB::Listener" + ], + "target_properties": [ + "LoadBalancerId" + ], + "target_types": [ + "ALIYUN::SLB::LoadBalancer" + ] + }, + { + "label": { + "en": "associates with", + "zh": "绑定任播弹性公网IP" + }, + "resource_types": [ + "ALIYUN::VPC::AnycastEIPAssociation" + ], + "target_properties": [ + "BindInstanceId" + ], + "target_types": [ + "ALIYUN::ECS::Instance", + "ALIYUN::SLB::LoadBalancer", + "ALIYUN::VPC::HaVip", + "ALIYUN::ECS::NetworkInterface" + ] + }, + { + "label": { + "en": "Associate VPC", + "zh": "DHCP选项集关联" + }, + "resource_types": [ + "ALIYUN::VPC::DhcpOptionsSetAttachment" + ], + "target_properties": [ + "VpcId" + ], + "target_types": [ + "ALIYUN::ECS::VPC" + ] + }, + { + "label": { + "en": "associates with", + "zh": "弹性公网IP关联" + }, + "resource_types": [ + "ALIYUN::VPC::EIPAssociation" + ], + "target_properties": [ + "InstanceId" + ], + "target_types": [ + "ALIYUN::ECS::Instance", + "ALIYUN::SLB::LoadBalancer", + "ALIYUN::VPC::HaVip", + "ALIYUN::ECS::InstanceGroup", + "ALIYUN::ECS::InstanceGroupClone", + "ALIYUN::ECS::NetworkInterface" + ] + }, + { + "label": { + "en": "Associate Instance", + "zh": "绑定高可用虚拟IP" + }, + "resource_types": [ + "ALIYUN::VPC::HaVipAssociation" + ], + "target_properties": [ + "InstanceId" + ], + "target_types": [ + "ALIYUN::ECS::Instance", + "ALIYUN::ECS::InstanceGroup" + ] + }, + { + "label": { + "en": "Associate vSwitch", + "zh": "网络ACL关联" + }, + "resource_types": [ + "ALIYUN::VPC::NetworkAclAssociation" + ], + "target_properties": [ + "Resources" + ], + "target_types": [ + "ALIYUN::ECS::VSwitch" + ] + }, + { + "label": { + "en": "Associate vSwitch", + "zh": "VPC路由表关联" + }, + "resource_types": [ + "ALIYUN::VPC::RouteTableAssociation" + ], + "target_properties": [ + "VSwitchId" + ], + "target_types": [ + "ALIYUN::ECS::VSwitch" + ] + }, + { + "label": { + "en": "Add Mirror Source", + "zh": "镜像会话镜像源" + }, + "resource_types": [ + "ALIYUN::VPC::TrafficMirrorSessionSourcesAddition" + ], + "target_properties": [ + "TrafficMirrorSourceIds" + ], + "target_types": [ + "ALIYUN::ECS::NetworkInterface" + ] + }, + { + "label": { + "en": "AScript Rule", + "zh": "AScript规则" + }, + "resource_types": [ + "ALIYUN::ALB::AScript" + ], + "target_properties": [ + "ListenerId" + ], + "target_types": [ + "ALIYUN::ALB::Listener" + ] + }, + { + "label": { + "en": "Attach Backend Server", + "zh": "添加后端服务器" + }, + "resource_types": [ + "ALIYUN::ALB::BackendServerAttachment" + ], + "target_properties": [ + "ServerGroupId" + ], + "target_types": [ + "ALIYUN::ALB::ServerGroup" + ] + }, + { + "label": { + "en": "Forwarding Rule", + "zh": "转发规则" + }, + "resource_types": [ + "ALIYUN::ALB::Rule" + ], + "target_properties": [ + "ListenerId" + ], + "target_types": [ + "ALIYUN::ALB::Listener" + ] + }, + { + "label": { + "en": "Listener", + "zh": "监听" + }, + "keep_when_bridge_via": true, + "resource_types": [ + "ALIYUN::ALB::Listener" + ], + "target_properties": [ + "LoadBalancerId" + ], + "target_types": [ + "ALIYUN::ALB::LoadBalancer" + ] + }, + { + "label": { + "en": "Binding", + "zh": "绑定" + }, + "resource_types": [ + "ALIYUN::AMQP::Binding" + ], + "target_properties": [ + "InstanceId" + ], + "target_types": [ + "ALIYUN::AMQP::Instance" + ] + }, + { + "label": { + "en": "Route", + "zh": "路由" + }, + "resource_types": [ + "ALIYUN::APIG::Route" + ], + "target_properties": [ + "HttpApiId", + "GatewayId" + ], + "target_types": [ + "ALIYUN::APIG::HttpApi", + "ALIYUN::APIG::Gateway" + ] + }, + { + "label": { + "en": "Custom Domain", + "zh": "自定义域名" + }, + "resource_types": [ + "ALIYUN::ApiGateway::CustomDomain" + ], + "target_properties": [ + "GroupId" + ], + "target_types": [ + "ALIYUN::ApiGateway::Group" + ] + }, + { + "label": { + "en": "Plugin Attachment", + "zh": "插件绑定" + }, + "resource_types": [ + "ALIYUN::ApiGateway::PluginAttachment" + ], + "target_properties": [ + "ApiId", + "PluginId" + ], + "target_types": [ + "ALIYUN::ApiGateway::Api", + "ALIYUN::ApiGateway::Plugin" + ] + }, + { + "label": { + "en": "Stage Config", + "zh": "环境变量配置" + }, + "resource_types": [ + "ALIYUN::ApiGateway::StageConfig" + ], + "target_properties": [ + "GroupId" + ], + "target_types": [ + "ALIYUN::ApiGateway::Group" + ] + }, + { + "label": { + "en": "VPC Access Config", + "zh": "VPC授权配置" + }, + "resource_types": [ + "ALIYUN::ApiGateway::VpcAccessConfig" + ], + "target_properties": [ + "InstanceId", + "VpcId" + ], + "target_types": [ + "ALIYUN::ApiGateway::Instance", + "ALIYUN::ECS::VPC" + ] + }, + { + "label": { + "en": "Domain Config", + "zh": "域名配置" + }, + "resource_types": [ + "ALIYUN::CDN::DomainConfig" + ], + "target_properties": [ + "DomainNames" + ], + "target_types": [ + "ALIYUN::CDN::Domain" + ] + }, + { + "label": { + "en": "CEN Bandwidth Limit", + "zh": "跨地域带宽限制" + }, + "resource_types": [ + "ALIYUN::CEN::CenBandwidthLimit" + ], + "target_properties": [ + "CenId" + ], + "target_types": [ + "ALIYUN::CEN::CenInstance" + ] + }, + { + "label": { + "en": "Bandwidth Package", + "zh": "带宽包" + }, + "resource_types": [ + "ALIYUN::CEN::CenBandwidthPackageAssociation" + ], + "target_properties": [ + "CenId" + ], + "target_types": [ + "ALIYUN::CEN::CenInstance" + ] + }, + { + "label": { + "en": "Network Instance", + "zh": "网络实例" + }, + "resource_types": [ + "ALIYUN::CEN::CenInstanceAttachment" + ], + "target_properties": [ + "CenId" + ], + "target_types": [ + "ALIYUN::CEN::CenInstance" + ] + }, + { + "label": { + "en": "Route Map", + "zh": "路由策略" + }, + "resource_types": [ + "ALIYUN::CEN::CenRouteMap" + ], + "target_properties": [ + "CenId" + ], + "target_types": [ + "ALIYUN::CEN::CenInstance" + ] + }, + { + "label": { + "en": "Cloud Service", + "zh": "云服务" + }, + "resource_types": [ + "ALIYUN::CEN::CenRouteService" + ], + "target_properties": [ + "CenId" + ], + "target_types": [ + "ALIYUN::CEN::CenInstance" + ] + }, + { + "label": { + "en": "Health Check", + "zh": "健康检查" + }, + "resource_types": [ + "ALIYUN::CEN::CenVbrHealthCheck" + ], + "target_properties": [ + "CenId" + ], + "target_types": [ + "ALIYUN::CEN::CenInstance" + ] + }, + { + "label": { + "en": "Route Entry", + "zh": "路由条目" + }, + "resource_types": [ + "ALIYUN::CEN::ChildInstanceRouteEntryToAttachment" + ], + "target_properties": [ + "CenId" + ], + "target_types": [ + "ALIYUN::CEN::CenInstance" + ] + }, + { + "label": { + "en": "Route Entry", + "zh": "路由条目" + }, + "resource_types": [ + "ALIYUN::CEN::RouteEntry" + ], + "target_properties": [ + "CenId" + ], + "target_types": [ + "ALIYUN::CEN::CenInstance" + ] + }, + { + "label": { + "en": "Cross-region Connection", + "zh": "跨地域连接" + }, + "resource_types": [ + "ALIYUN::CEN::TransitRouterPeerAttachment" + ], + "target_properties": [ + "TransitRouterId" + ], + "target_types": [ + "ALIYUN::CEN::TransitRouter" + ] + }, + { + "label": { + "en": "Route Entry", + "zh": "路由条目" + }, + "resource_types": [ + "ALIYUN::CEN::TransitRouterRouteEntry" + ], + "target_properties": [ + "TransitRouterRouteTableId" + ], + "target_types": [ + "ALIYUN::CEN::TransitRouterRouteTable", + "ALIYUN::CEN::TransitRouter" + ] + }, + { + "label": { + "en": "Website Forwarding Rule", + "zh": "网站转发规则" + }, + "resource_types": [ + "ALIYUN::DDoSPro::WebRule" + ], + "target_properties": [ + "InstanceIds" + ], + "target_types": [ + "ALIYUN::DDoSPro::ProInstance", + "ALIYUN::DDoSPro::PremiumInstance", + "ALIYUN::DDoS::OriginInstance" + ] + }, + { + "label": { + "en": "DRDS Database", + "zh": "分布式数据库" + }, + "resource_types": [ + "ALIYUN::DRDS::DrdsDB" + ], + "target_properties": [ + "DrdsInstanceId" + ], + "target_types": [ + "ALIYUN::DRDS::DrdsInstance" + ] + }, + { + "label": { + "en": "Attach", + "zh": "绑定" + }, + "resource_types": [ + "ALIYUN::EAIS::ClientInstanceAttachment" + ], + "target_properties": [ + "InstanceId", + "ClientInstanceId" + ], + "target_types": [ + "ALIYUN::EAIS::Instance", + "ALIYUN::ECS::Instance" + ] + }, + { + "label": { + "en": "Assign IP", + "zh": "分配IP" + }, + "resource_types": [ + "ALIYUN::ECS::AssignPrivateIpAddresses" + ], + "target_properties": [ + "NetworkInterfaceId" + ], + "target_types": [ + "ALIYUN::ECS::NetworkInterface" + ] + }, + { + "label": { + "en": "Snapshot", + "zh": "快照" + }, + "resource_types": [ + "ALIYUN::ECS::Snapshot" + ], + "target_properties": [ + "DiskId" + ], + "target_types": [ + "ALIYUN::ECS::Disk" + ] + }, + { + "label": { + "en": "Deploy Group", + "zh": "部署分组" + }, + "resource_types": [ + "ALIYUN::EDAS::DeployGroup" + ], + "target_properties": [ + "AppId" + ], + "target_types": [ + "ALIYUN::EDAS::Application" + ] + }, + { + "label": { + "en": "Auto Scale Config", + "zh": "自动伸缩配置" + }, + "resource_types": [ + "ALIYUN::EHPC::AutoScaleConfig" + ], + "target_properties": [ + "ClusterId" + ], + "target_types": [ + "ALIYUN::EHPC::Cluster" + ] + }, + { + "label": { + "en": "Alarm Task", + "zh": "报警任务" + }, + "resource_types": [ + "ALIYUN::ESS::AlarmTask" + ], + "target_properties": [ + "ScalingGroupId" + ], + "target_types": [ + "ALIYUN::ESS::ScalingGroup" + ] + }, + { + "label": { + "en": "Lifecycle Hook", + "zh": "生命周期挂钩" + }, + "resource_types": [ + "ALIYUN::ESS::LifecycleHook" + ], + "target_properties": [ + "ScalingGroupId" + ], + "target_types": [ + "ALIYUN::ESS::ScalingGroup" + ] + }, + { + "label": { + "en": "Scaling Configuration", + "zh": "伸缩配置" + }, + "resource_types": [ + "ALIYUN::ESS::ScalingConfiguration" + ], + "target_properties": [ + "ScalingGroupId" + ], + "target_types": [ + "ALIYUN::ESS::ScalingGroup" + ] + }, + { + "label": { + "en": "Scaling Rule", + "zh": "伸缩规则" + }, + "resource_types": [ + "ALIYUN::ESS::ScalingRule" + ], + "target_properties": [ + "ScalingGroupId" + ], + "target_types": [ + "ALIYUN::ESS::ScalingGroup" + ] + }, + { + "label": { + "en": "Scheduled Task", + "zh": "定时任务" + }, + "resource_types": [ + "ALIYUN::ESS::ScheduledTask" + ], + "target_properties": [ + "ScalingGroupId" + ], + "target_types": [ + "ALIYUN::ESS::ScalingGroup" + ] + }, + { + "label": { + "en": "Attach Server Group", + "zh": "关联服务器组" + }, + "resource_types": [ + "ALIYUN::ESS::ServerGroupAttachment" + ], + "target_properties": [ + "ScalingGroupId" + ], + "target_types": [ + "ALIYUN::ESS::ScalingGroup" + ] + }, + { + "label": { + "en": "Forwarding Rules", + "zh": "转发规则" + }, + "resource_types": [ + "ALIYUN::GA::ForwardingRules" + ], + "target_properties": [ + "AcceleratorId", + "ListenerId" + ], + "target_types": [ + "ALIYUN::GA::Accelerator", + "ALIYUN::GA::Listener" + ] + }, + { + "label": { + "en": "Listener", + "zh": "监听" + }, + "resource_types": [ + "ALIYUN::GA::Listener" + ], + "target_properties": [ + "AcceleratorId" + ], + "target_types": [ + "ALIYUN::GA::Accelerator" + ] + }, + { + "label": { + "en": "Rule Action", + "zh": "规则动作" + }, + "resource_types": [ + "ALIYUN::IOT::RuleAction" + ], + "target_properties": [ + "RuleId" + ], + "target_types": [ + "ALIYUN::IOT::Rule" + ] + }, + { + "label": { + "en": "Namespace", + "zh": "命名空间" + }, + "resource_types": [ + "ALIYUN::MSE::EngineNamespace" + ], + "target_properties": [ + "InstanceId" + ], + "target_types": [ + "ALIYUN::MSE::Cluster" + ] + }, + { + "label": { + "en": "Data Flow", + "zh": "数据流" + }, + "resource_types": [ + "ALIYUN::NAS::DataFlow" + ], + "target_properties": [ + "FileSystemId" + ], + "target_types": [ + "ALIYUN::NAS::FileSystem" + ] + }, + { + "label": { + "en": "Protocol Export Directory", + "zh": "协议服务导出目录" + }, + "resource_types": [ + "ALIYUN::NAS::ProtocolMountTarget" + ], + "target_properties": [ + "FileSystemId" + ], + "target_types": [ + "ALIYUN::NAS::FileSystem" + ] + }, + { + "label": { + "en": "Listener", + "zh": "监听" + }, + "keep_when_bridge_via": true, + "resource_types": [ + "ALIYUN::NLB::Listener" + ], + "target_properties": [ + "LoadBalancerId" + ], + "target_types": [ + "ALIYUN::NLB::LoadBalancer" + ] + }, + { + "label": { + "en": "Website Hosting", + "zh": "静态网站托管" + }, + "resource_types": [ + "ALIYUN::OSS::Website" + ], + "target_properties": [ + "BucketName" + ], + "target_types": [ + "ALIYUN::OSS::Bucket" + ] + }, + { + "label": { + "en": "Code Source", + "zh": "代码源" + }, + "resource_types": [ + "ALIYUN::PAI::CodeSource" + ], + "target_properties": [ + "WorkspaceId" + ], + "target_types": [ + "ALIYUN::PAI::Workspace" + ] + }, + { + "label": { + "en": "Dataset", + "zh": "数据集" + }, + "resource_types": [ + "ALIYUN::PAI::Dataset" + ], + "target_properties": [ + "WorkspaceId" + ], + "target_types": [ + "ALIYUN::PAI::Workspace" + ] + }, + { + "label": { + "en": "Experiment", + "zh": "实验" + }, + "resource_types": [ + "ALIYUN::PAI::Experiment" + ], + "target_properties": [ + "WorkspaceId" + ], + "target_types": [ + "ALIYUN::PAI::Workspace" + ] + }, + { + "label": { + "en": "Public Endpoint", + "zh": "公网地址" + }, + "resource_types": [ + "ALIYUN::POLARDB::DBClusterEndpointAddress" + ], + "target_properties": [ + "DBClusterId", + "DBEndpointId" + ], + "target_types": [ + "ALIYUN::POLARDB::DBCluster", + "ALIYUN::POLARDB::DBClusterEndpoint" + ] + }, + { + "label": { + "en": "Database", + "zh": "数据库" + }, + "resource_types": [ + "ALIYUN::POLARDB::Database" + ], + "target_properties": [ + "DBClusterId" + ], + "target_types": [ + "ALIYUN::POLARDB::DBCluster" + ] + }, + { + "label": { + "en": "Consumer Group", + "zh": "消费者组" + }, + "resource_types": [ + "ALIYUN::ROCKETMQ5::ConsumerGroup" + ], + "target_properties": [ + "InstanceId" + ], + "target_types": [ + "ALIYUN::ROCKETMQ5::Instance" + ] + }, + { + "label": { + "en": "Scaling Rule", + "zh": "扩缩容规则" + }, + "resource_types": [ + "ALIYUN::SAE::ApplicationScalingRule" + ], + "target_properties": [ + "AppId" + ], + "target_types": [ + "ALIYUN::SAE::Application" + ] + }, + { + "label": { + "en": "Ingress Rule", + "zh": "路由规则" + }, + "resource_types": [ + "ALIYUN::SAE::Ingress" + ], + "target_properties": [ + "SlbId" + ], + "target_types": [ + "ALIYUN::SLB::LoadBalancer" + ] + }, + { + "label": { + "en": "SLB Binding", + "zh": "绑定SLB" + }, + "resource_types": [ + "ALIYUN::SAE::SlbBinding" + ], + "target_properties": [ + "AppId" + ], + "target_types": [ + "ALIYUN::SAE::Application" + ] + }, + { + "label": { + "en": "Device Binding", + "zh": "设备绑定" + }, + "resource_types": [ + "ALIYUN::SAG::SerialNumberBinding" + ], + "target_properties": [ + "SmartAGId" + ], + "target_types": [ + "ALIYUN::SAG::SmartAccessGateway" + ] + }, + { + "label": { + "en": "Backend Server", + "zh": "后端服务器" + }, + "resource_types": [ + "ALIYUN::SLB::BackendServerAttachment" + ], + "target_properties": [ + "LoadBalancerId" + ], + "target_types": [ + "ALIYUN::SLB::LoadBalancer" + ] + }, + { + "label": { + "en": "Forwarding Rule", + "zh": "转发规则" + }, + "resource_types": [ + "ALIYUN::SLB::Rule" + ], + "target_properties": [ + "LoadBalancerId" + ], + "target_types": [ + "ALIYUN::SLB::LoadBalancer" + ] + }, + { + "label": { + "en": "vServer Group", + "zh": "虚拟服务器组" + }, + "resource_types": [ + "ALIYUN::SLB::VServerGroup" + ], + "target_properties": [ + "LoadBalancerId" + ], + "target_types": [ + "ALIYUN::SLB::LoadBalancer" + ] + }, + { + "label": { + "en": "BGP Group", + "zh": "BGP组" + }, + "resource_types": [ + "ALIYUN::VPC::BgpGroup" + ], + "target_properties": [ + "RouterId" + ], + "target_types": [ + "ALIYUN::VPC::VirtualBorderRouter" + ] + }, + { + "label": { + "en": "Network ACL", + "zh": "网络ACL" + }, + "resource_types": [ + "ALIYUN::VPC::NetworkAcl" + ], + "target_properties": [ + "VpcId" + ], + "target_types": [ + "ALIYUN::ECS::VPC" + ] + }, + { + "label": { + "en": "SSL-VPN Server", + "zh": "SSL-VPN服务端" + }, + "resource_types": [ + "ALIYUN::VPC::SslVpnServer" + ], + "target_properties": [ + "VpnGatewayId" + ], + "target_types": [ + "ALIYUN::VPC::VpnGateway" + ] + }, + { + "label": { + "en": "Reserved CIDR", + "zh": "预留网段" + }, + "resource_types": [ + "ALIYUN::VPC::VSwitchCidrReservation" + ], + "target_properties": [ + "VSwitchId" + ], + "target_types": [ + "ALIYUN::ECS::VSwitch" + ] + }, + { + "label": { + "en": "Secondary CIDR", + "zh": "附加网段" + }, + "resource_types": [ + "ALIYUN::VPC::VpcCidrBlockAssociation" + ], + "target_properties": [ + "VpcId" + ], + "target_types": [ + "ALIYUN::ECS::VPC" + ] + }, + { + "label": { + "en": "PBR Route", + "zh": "策略路由" + }, + "resource_types": [ + "ALIYUN::VPC::VpnPbrRouteEntry" + ], + "target_properties": [ + "VpnGatewayId" + ], + "target_types": [ + "ALIYUN::VPC::VpnGateway" + ] + }, + { + "label": { + "en": "Destination Route", + "zh": "目的路由" + }, + "resource_types": [ + "ALIYUN::VPC::VpnRouteEntry" + ], + "target_properties": [ + "VpnGatewayId" + ], + "target_types": [ + "ALIYUN::VPC::VpnGateway" + ] + }, + { + "label": { + "en": "Domain Config", + "zh": "域名配置" + }, + "resource_types": [ + "ALIYUN::WAF::DomainConfig" + ], + "target_properties": [ + "InstanceId" + ], + "target_types": [ + "ALIYUN::WAF::Instance" + ] + } + ], + "compact_concept_nodes": [ + { + "controller_edge": { + "label": { + "en": "scales", + "zh": "弹性伸缩" + }, + "style": "solid_arrow", + "target": "concept" + }, + "controller_property": "ScalingGroupId", + "group": { + "id_suffix": "ApplicationGroup", + "label": { + "en": "Application server group", + "zh": "应用服务组" + }, + "members": [ + "source", + "concept" + ], + "resource_type": "CONCEPT::Application::ServerGroup", + "rewrite_edge_kinds": [ + "traffic", + "dependency", + "inferred" + ] + }, + "id_suffix": "ScaledEcs", + "label": { + "en": "Scaled ECS instances", + "zh": "伸缩 ECS 实例" + }, + "resource_type": "CONCEPT::ESS::ScaledECS", + "source_edge": { + "label": { + "en": "scaling config", + "zh": "伸缩配置" + }, + "style": "dotted_arrow", + "target": "controller" + }, + "source_property": "InstanceId", + "via_resource_types": [ + "ALIYUN::ESS::ScalingConfiguration" + ] + } + ], + "compact_flatten_layer_roles": [ + "security_group" + ], + "compact_hidden_short_types": [ + "AssignPrivateIpAddresses", + "AutoEnableService", + "AccountPrivilege", + "CustomImage", + "DBClusterAccessWhiteList", + "DBNodes", + "DomainRecord", + "ScalingGroupEnable", + "ScalingRule", + "Sleep", + "Whitelist", + "WaitCondition", + "WaitConditionHandle" + ], + "compact_orchestration_actions": [ + { + "evidence_properties": [ + "CommandContent" + ], + "resource_types": [ + "ALIYUN::ECS::Command" + ] + }, + { + "command_properties": [ + "CommandId" + ], + "resource_types": [ + "ALIYUN::ECS::Invocation" + ], + "target_properties": [ + "InstanceId", + "InstanceIds" + ] + }, + { + "evidence_properties": [ + "CommandContent" + ], + "resource_types": [ + "ALIYUN::ECS::RunCommand" + ], + "target_properties": [ + "InstanceId", + "InstanceIds" + ] + }, + { + "command_properties": [ + "Command" + ], + "evidence_properties": [ + "RunAgainOn" + ], + "resource_types": [ + "ALIYUN::CloudPhone::RunCommand" + ], + "target_properties": [ + "InstanceIds" + ] + }, + { + "command_properties": [ + "CommandContent", + "CommandContentOnDeletion" + ], + "evidence_properties": [ + "Name", + "Type" + ], + "resource_types": [ + "ALIYUN::ECS::RunCommandOfLifespan" + ], + "target_properties": [ + "InstanceIds" + ] + }, + { + "command_properties": [ + "CommandContent", + "Name" + ], + "evidence_properties": [ + "Type", + "WorkingDir" + ], + "resource_types": [ + "ALIYUN::SWAS::RunCommand" + ], + "target_properties": [ + "InstanceId" + ] + }, + { + "command_properties": [ + "StageName" + ], + "evidence_properties": [ + "HistoryVersion" + ], + "resource_types": [ + "ALIYUN::ApiGateway::Deployment" + ], + "target_properties": [ + "ApiId", + "GroupId" + ] + }, + { + "command_properties": [ + "Script" + ], + "evidence_properties": [ + "Tid" + ], + "resource_types": [ + "ALIYUN::DMS::ScriptExecution" + ], + "target_properties": [ + "DbId" + ] + }, + { + "command_properties": [ + "Strategy" + ], + "evidence_properties": [ + "DeploymentSetName" + ], + "resource_types": [ + "ALIYUN::ECS::DeploymentSet" + ], + "target_properties": [] + }, + { + "command_properties": [ + "ScheduledPreloadJobId" + ], + "evidence_properties": [ + "StartTime", + "EndTime" + ], + "resource_types": [ + "ALIYUN::ESA::ScheduledPreloadExecution" + ], + "target_properties": [] + }, + { + "command_properties": [ + "Enable" + ], + "evidence_properties": [], + "resource_types": [ + "ALIYUN::ESS::AlarmTaskEnable" + ], + "target_properties": [ + "AlarmTaskId" + ] + }, + { + "command_properties": [ + "ScalingConfigurationId", + "InstanceIds" + ], + "evidence_properties": [], + "resource_types": [ + "ALIYUN::ESS::ScalingGroupEnable" + ], + "target_properties": [ + "ScalingGroupId" + ] + }, + { + "command_properties": [ + "DeployParameters", + "RevisionId" + ], + "evidence_properties": [ + "ApplicationName", + "Name" + ], + "resource_types": [ + "ALIYUN::OOS::ApplicationGroupDeployment" + ], + "target_properties": [ + "ApplicationName", + "Name" + ] + }, + { + "command_properties": [ + "Hooks", + "Location", + "RevisionType" + ], + "evidence_properties": [ + "ApplicationName" + ], + "resource_types": [ + "ALIYUN::OOS::DeployRevision" + ], + "target_properties": [ + "ApplicationName" + ] + }, + { + "command_properties": [ + "TemplateName", + "TemplateURL", + "Parameters" + ], + "evidence_properties": [ + "TemplateName", + "TemplateURL" + ], + "resource_types": [ + "ALIYUN::OOS::Execution" + ], + "target_properties": [ + "ResourceGroupId" + ] + }, + { + "command_properties": [ + "RunName", + "SourceId", + "SourceType" + ], + "evidence_properties": [], + "resource_types": [ + "ALIYUN::PAI::Run" + ], + "target_properties": [ + "ExperimentId" + ] + }, + { + "command_properties": [ + "DBInstanceId", + "DBName" + ], + "evidence_properties": [ + "OSSUrls", + "BackupMode" + ], + "resource_types": [ + "ALIYUN::RDS::MigrateTask" + ], + "target_properties": [ + "DBInstanceId" + ] + }, + { + "command_properties": [ + "ServiceName" + ], + "evidence_properties": [], + "resource_types": [ + "ALIYUN::ROS::AutoEnableService" + ], + "target_properties": [] + }, + { + "command_properties": [ + "Handle", + "Timeout", + "Count" + ], + "evidence_properties": [], + "resource_types": [ + "ALIYUN::ROS::WaitCondition" + ], + "target_properties": [] + } + ], + "compact_relation_folds": [ + { + "edge_label": { + "en": "VPC connection", + "zh": "VPC连接" + }, + "edge_style": "dotted_open", + "render_as": "source_attachment", + "source_property": "TransitRouterId", + "target_property": "VpcId", + "via_resource_types": [ + "ALIYUN::CEN::TransitRouterVpcAttachment" + ] + } + ], + "compact_resource_labels": { + "ALIYUN::ECS::NetworkInterface": "ENI", + "ALIYUN::ESS::ScalingConfiguration": "ESS Config", + "ALIYUN::ESS::ScalingGroup": "ESS Group", + "ALIYUN::ESS::ScalingGroupEnable": "ESS Enable", + "ALIYUN::ESS::ScalingRule": "ESS Rule", + "ALIYUN::POLARDB::DBCluster": "PolarDB", + "ALIYUN::POLARDB::DBClusterAccessWhiteList": "PolarDB Whitelist", + "ALIYUN::REDIS::Instance": "Redis Instance", + "ALIYUN::REDIS::Whitelist": "Redis Whitelist", + "ALIYUN::VPC::AnycastEIP": "Anycast EIP", + "ALIYUN::VPC::CommonBandwidthPackageIp": "Bandwidth IP", + "ALIYUN::VPC::EIP": "EIP", + "ALIYUN::VPC::HaVip": "HA-VIP" + }, + "containment_layer_types": { + "cloud_network": [ + "ALIYUN::CEN::CenInstance" + ], + "security_group": [ + "ALIYUN::ECS::SecurityGroup" + ], + "vpc": [ + "ALIYUN::ECS::VPC" + ], + "vswitch": [ + "ALIYUN::ECS::VSwitch" + ], + "workspace": [ + "ALIYUN::PAI::Workspace" + ] + }, + "edge_operators": { + "dotted_arrow": "-.->", + "dotted_open": "-.-", + "solid_arrow": "-->" + }, + "edge_styles": { + "auxiliary_relation": "solid_arrow", + "direct_relation": "dotted_open" + }, + "fallback_related_properties": { + "SecurityGroupId": [ + "ALIYUN::ECS::SecurityGroup" + ], + "SecurityGroupIds": [ + "ALIYUN::ECS::SecurityGroup" + ], + "VSwitchId": [ + "ALIYUN::ECS::VSwitch" + ], + "VpcId": [ + "ALIYUN::ECS::VPC" + ], + "ClusterId": [ + "ALIYUN::CS::ManagedKubernetesCluster", + "ALIYUN::CS::KubernetesCluster", + "ALIYUN::CS::ManagedEdgeKubernetesCluster", + "ALIYUN::CS::ServerlessKubernetesCluster" + ] + }, + "legacy_auxiliary_short_types": [ + "SecurityGroupIngress", + "SecurityGroupEgress", + "EIPAssociation", + "BackendServerAttachment", + "Listener", + "VServerGroup", + "Account" + ], + "legacy_layer_labels": { + "ALIYUN::ECS::SecurityGroup": "Security group", + "ALIYUN::ECS::VPC": "VPC", + "ALIYUN::ECS::VSwitch": "VSwitch" + }, + "legacy_resource_labels": { + "ALIYUN::ECS::Instance": "ECS instance", + "ALIYUN::ECS::InstanceGroup": "ECS instance group", + "ALIYUN::SLB::LoadBalancer": "SLB load balancer", + "ALIYUN::VPC::CommonBandwidthPackage": "Shared bandwidth package", + "ALIYUN::VPC::EIP": "Elastic IP address", + "ALIYUN::VPC::NatGateway": "NAT gateway" + }, + "network_layer_types": [ + "ALIYUN::ECS::VPC", + "ALIYUN::ECS::VSwitch", + "ALIYUN::ECS::SecurityGroup" + ], + "supplemental_related_properties": { + "ALIYUN::ALB::BackendServerAttachment": { + "Servers.ServerId": [ + "ALIYUN::ECS::Instance", + "ALIYUN::ECS::InstanceGroup" + ] + }, + "ALIYUN::ALB::Listener": { + "DefaultActions.ForwardGroupConfig.ServerGroupTuples.ServerGroupId": [ + "ALIYUN::ALB::ServerGroup" + ] + }, + "ALIYUN::CEN::TransitRouterRouteEntry": { + "TransitRouterRouteTableId": [ + "ALIYUN::CEN::TransitRouter" + ], + "TransitRouterRouteEntryNextHopId": [ + "ALIYUN::CEN::TransitRouterPeerAttachment", + "ALIYUN::CEN::TransitRouterRouteTableAssociation", + "ALIYUN::CEN::TransitRouterVbrAttachment", + "ALIYUN::CEN::TransitRouterVpcAttachment", + "ALIYUN::CEN::TransitRouterVpnAttachment" + ] + }, + "ALIYUN::CEN::TransitRouterRouteTableAssociation": { + "TransitRouterRouteTableId": [ + "ALIYUN::CEN::TransitRouter" + ] + }, + "ALIYUN::CEN::TransitRouterRouteTablePropagation": { + "TransitRouterRouteTableId": [ + "ALIYUN::CEN::TransitRouter" + ] + }, + "ALIYUN::ECS::Route": { + "NextHopId": [ + "ALIYUN::CEN::TransitRouterPeerAttachment", + "ALIYUN::CEN::TransitRouterVbrAttachment", + "ALIYUN::CEN::TransitRouterVpcAttachment", + "ALIYUN::CEN::TransitRouterVpnAttachment", + "ALIYUN::ECS::Instance", + "ALIYUN::ECS::InstanceGroup", + "ALIYUN::ECS::NetworkInterface", + "ALIYUN::VPC::HaVip", + "ALIYUN::VPC::IPv4Gateway", + "ALIYUN::VPC::NatGateway", + "ALIYUN::VPC::RouterInterface", + "ALIYUN::VPN::VpnGateway" + ], + "RouteTableId": [ + "ALIYUN::VPC::RouteTable" + ] + }, + "ALIYUN::NAS::MountTarget": { + "AccessGroupName": [ + "ALIYUN::NAS::AccessGroup" + ] + }, + "ALIYUN::NLB::ServerGroup": { + "Servers.ServerId": [ + "ALIYUN::ALB::LoadBalancer", + "ALIYUN::ECS::Instance", + "ALIYUN::ECS::InstanceGroup" + ] + }, + "ALIYUN::POLARDB::DBCluster": { + "SourceResourceId": [ + "ALIYUN::RDS::DBInstance", + "ALIYUN::RDS::PrepayDBInstance" + ] + }, + "ALIYUN::POLARDB::DBInstance": { + "DBClusterId": [ + "ALIYUN::POLARDB::DBCluster" + ] + }, + "ALIYUN::POLARDB::DBNodes": { + "DBClusterId": [ + "ALIYUN::POLARDB::DBCluster" + ] + }, + "MODULE::ACS::ComputeNest::FluxOciHelmDeploy": { + "ClusterId": [ + "ALIYUN::CS::ManagedKubernetesCluster", + "ALIYUN::CS::KubernetesCluster", + "ALIYUN::CS::ManagedEdgeKubernetesCluster", + "ALIYUN::CS::ServerlessKubernetesCluster" + ] + }, + "ALIYUN::RAM::AccessKey": { + "UserName": [ + "ALIYUN::RAM::User" + ] + }, + "ALIYUN::RAM::UserToGroupAddition": { + "Users": [ + "ALIYUN::RAM::User" + ], + "GroupName": [ + "ALIYUN::RAM::Group" + ] + }, + "ALIYUN::SLS::Logstore": { + "ProjectName": [ + "ALIYUN::SLS::Project" + ] + }, + "ALIYUN::VPC::AnycastEIPAssociation": { + "BindInstanceId": [ + "ALIYUN::ECS::Instance", + "ALIYUN::ECS::NetworkInterface", + "ALIYUN::SLB::LoadBalancer", + "ALIYUN::VPC::HaVip" + ] + }, + "ALIYUN::VPC::CommonBandwidthPackageIp": { + "Eips": [ + "ALIYUN::VPC::EIP" + ] + }, + "ALIYUN::VPC::EIPAssociation": { + "InstanceId": [ + "ALIYUN::ECS::NetworkInterface", + "ALIYUN::VPC::NatGateway" + ] + }, + "ALIYUN::VPC::FullNatEntry": { + "FullNatTableId": [ + "ALIYUN::VPC::NatGateway" + ] + }, + "ALIYUN::VPC::NetworkAclAssociation": { + "Resources": [ + "ALIYUN::ECS::VSwitch" + ] + }, + "ALIYUN::VPC::PeeringRouterInterfaceBinding": { + "OppositeInterfaceId": [ + "ALIYUN::VPC::RouterInterface" + ] + } + } +} diff --git a/src/iac_code/pipeline/engine/architecture_rules.py b/src/iac_code/pipeline/engine/architecture_rules.py new file mode 100644 index 00000000..2296ad20 --- /dev/null +++ b/src/iac_code/pipeline/engine/architecture_rules.py @@ -0,0 +1,465 @@ +"""Fixed supplemental rules for architecture diagram rendering.""" + +from __future__ import annotations + +import json +from dataclasses import dataclass +from pathlib import Path +from typing import Any, ClassVar + +RuleLabel = str | dict[str, str] + + +@dataclass(frozen=True) +class EdgeStyles: + auxiliary_relation: str + direct_relation: str + + +@dataclass(frozen=True) +class CompactRelationFold: + via_resource_types: frozenset[str] + source_property: str + target_property: str + edge_style: str + edge_label: RuleLabel | None + render_as: str = "edge" + + +@dataclass(frozen=True) +class CompactChildAttachment: + resource_types: tuple[str, ...] + target_properties: tuple[str, ...] + target_types: tuple[str, ...] + label: RuleLabel + keep_when_bridge_via: bool = False + + +@dataclass(frozen=True) +class CompactBridgeAttachment: + resource_types: tuple[str, ...] + source_properties: tuple[str, ...] + via_resource_types: tuple[str, ...] + via_source_properties: tuple[str, ...] + via_target_properties: tuple[str, ...] + target_types: tuple[str, ...] + label: RuleLabel + target_self: bool = False + + +@dataclass(frozen=True) +class CompactAttachmentEdge: + resource_types: tuple[str, ...] + source_properties: tuple[str, ...] + marker_properties: tuple[str, ...] + source_types: tuple[str, ...] + marker_types: tuple[str, ...] + edge_style: str + edge_label: RuleLabel | None + + +@dataclass(frozen=True) +class CompactOrchestrationAction: + resource_types: tuple[str, ...] + command_properties: tuple[str, ...] + target_properties: tuple[str, ...] + evidence_properties: tuple[str, ...] + + +@dataclass(frozen=True) +class ConceptEdgeRule: + style: str + label: RuleLabel | None + target: str + + +@dataclass(frozen=True) +class CompactConceptGroup: + id_suffix: str + resource_type: str + label: RuleLabel + members: tuple[str, ...] + rewrite_edge_kinds: tuple[str, ...] + + +@dataclass(frozen=True) +class CompactConceptNode: + via_resource_types: frozenset[str] + controller_property: str + source_property: str + id_suffix: str + resource_type: str + label: RuleLabel + controller_edge: ConceptEdgeRule | None + source_edge: ConceptEdgeRule | None + group: CompactConceptGroup | None + + +@dataclass(frozen=True) +class ArchitectureRules: + """Supplemental rendering rules kept separate from synced resource metadata.""" + + network_layer_types: frozenset[str] + containment_layer_types: dict[str, tuple[str, ...]] + legacy_auxiliary_short_types: frozenset[str] + legacy_resource_labels: dict[str, str] + legacy_layer_labels: dict[str, str] + fallback_related_properties: dict[str, tuple[str, ...]] + supplemental_related_properties: dict[str, dict[str, tuple[str, ...]]] + compact_hidden_short_types: frozenset[str] + compact_resource_labels: dict[str, str] + compact_attachment_marker_types: frozenset[str] + compact_child_attachments: tuple[CompactChildAttachment, ...] + compact_bridge_attachments: tuple[CompactBridgeAttachment, ...] + compact_attachment_edges: tuple[CompactAttachmentEdge, ...] + compact_orchestration_actions: tuple[CompactOrchestrationAction, ...] + compact_flatten_layer_roles: frozenset[str] + attachment_label_prefix: str + edge_styles: EdgeStyles + compact_relation_folds: tuple[CompactRelationFold, ...] + compact_concept_nodes: tuple[CompactConceptNode, ...] + edge_operators: dict[str, str] + + _default: ClassVar[ArchitectureRules | None] = None + + @classmethod + def load_default(cls) -> ArchitectureRules: + if cls._default is None: + cls._default = cls.from_file(Path(__file__).with_name("architecture_rules.json")) + return cls._default + + @classmethod + def from_file(cls, path: Path) -> ArchitectureRules: + return cls.from_raw(json.loads(path.read_text(encoding="utf-8"))) + + @classmethod + def from_raw(cls, raw: Any) -> ArchitectureRules: + if not isinstance(raw, dict): + raise ValueError("architecture rules must be a JSON object") + edge_styles = _dict_value(raw, "edge_styles") + return cls( + network_layer_types=_string_set(raw.get("network_layer_types")), + containment_layer_types=_string_tuple_map(raw.get("containment_layer_types")), + legacy_auxiliary_short_types=_string_set(raw.get("legacy_auxiliary_short_types")), + legacy_resource_labels=_string_map(raw.get("legacy_resource_labels")), + legacy_layer_labels=_string_map(raw.get("legacy_layer_labels")), + fallback_related_properties=_string_tuple_map(raw.get("fallback_related_properties")), + supplemental_related_properties=_nested_string_tuple_map(raw.get("supplemental_related_properties")), + compact_hidden_short_types=_string_set(raw.get("compact_hidden_short_types")), + compact_resource_labels=_string_map(raw.get("compact_resource_labels")), + compact_attachment_marker_types=_string_set(raw.get("compact_attachment_marker_types")), + compact_child_attachments=tuple(_iter_compact_child_attachments(raw.get("compact_child_attachments"))), + compact_bridge_attachments=tuple(_iter_compact_bridge_attachments(raw.get("compact_bridge_attachments"))), + compact_attachment_edges=tuple(_iter_compact_attachment_edges(raw.get("compact_attachment_edges"))), + compact_orchestration_actions=tuple( + _iter_compact_orchestration_actions(raw.get("compact_orchestration_actions")) + ), + compact_flatten_layer_roles=_string_set(raw.get("compact_flatten_layer_roles")), + attachment_label_prefix=( + raw.get("attachment_label_prefix") if isinstance(raw.get("attachment_label_prefix"), str) else "" + ), + edge_styles=EdgeStyles( + auxiliary_relation=_string_value(edge_styles, "auxiliary_relation"), + direct_relation=_string_value(edge_styles, "direct_relation"), + ), + compact_relation_folds=tuple(_iter_compact_relation_folds(raw.get("compact_relation_folds"))), + compact_concept_nodes=tuple(_iter_compact_concept_nodes(raw.get("compact_concept_nodes"))), + edge_operators=_string_map(raw.get("edge_operators")), + ) + + def edge_operator(self, style: str) -> str: + return self.edge_operators.get(style, "-->") + + def containment_types(self, role: str) -> tuple[str, ...]: + return self.containment_layer_types.get(role, ()) + + @property + def compact_orchestration_action_types(self) -> frozenset[str]: + return frozenset( + resource_type for action in self.compact_orchestration_actions for resource_type in action.resource_types + ) + + +def _dict_value(raw: dict[str, Any], key: str) -> dict[str, Any]: + value = raw.get(key) + return value if isinstance(value, dict) else {} + + +def _string_value(raw: dict[str, Any], key: str) -> str: + value = raw.get(key) + return value if isinstance(value, str) else "" + + +def _string_set(raw: Any) -> frozenset[str]: + if not isinstance(raw, list): + return frozenset() + return frozenset(item for item in raw if isinstance(item, str)) + + +def _string_map(raw: Any) -> dict[str, str]: + if not isinstance(raw, dict): + return {} + return {key: value for key, value in raw.items() if isinstance(key, str) and isinstance(value, str)} + + +def _string_tuple_map(raw: Any) -> dict[str, tuple[str, ...]]: + if not isinstance(raw, dict): + return {} + result: dict[str, tuple[str, ...]] = {} + for key, value in raw.items(): + if not isinstance(key, str) or not isinstance(value, list): + continue + result[key] = tuple(item for item in value if isinstance(item, str)) + return result + + +def _nested_string_tuple_map(raw: Any) -> dict[str, dict[str, tuple[str, ...]]]: + if not isinstance(raw, dict): + return {} + result: dict[str, dict[str, tuple[str, ...]]] = {} + for key, value in raw.items(): + nested = _string_tuple_map(value) + if isinstance(key, str) and nested: + result[key] = nested + return result + + +def _iter_compact_relation_folds(raw: Any) -> list[CompactRelationFold]: + if not isinstance(raw, list): + return [] + folds: list[CompactRelationFold] = [] + for item in raw: + if not isinstance(item, dict): + continue + via_resource_types = _string_set(item.get("via_resource_types")) + source_property = item.get("source_property") + target_property = item.get("target_property") + edge_style = item.get("edge_style") + edge_label = _rule_label(item.get("edge_label")) + render_as = item.get("render_as") if isinstance(item.get("render_as"), str) else "edge" + if not via_resource_types or not isinstance(source_property, str) or not isinstance(target_property, str): + continue + if not isinstance(edge_style, str): + continue + folds.append( + CompactRelationFold( + via_resource_types=via_resource_types, + source_property=source_property, + target_property=target_property, + edge_style=edge_style, + edge_label=edge_label, + render_as=render_as, + ) + ) + return folds + + +def _iter_compact_child_attachments(raw: Any) -> list[CompactChildAttachment]: + if not isinstance(raw, list): + return [] + attachments: list[CompactChildAttachment] = [] + for item in raw: + if not isinstance(item, dict): + continue + resource_types = _string_tuple(item.get("resource_types")) + target_properties = _string_tuple(item.get("target_properties")) + if not target_properties: + target_property = item.get("target_property") + target_properties = (target_property,) if isinstance(target_property, str) else () + target_types = _string_tuple(item.get("target_types")) + label = _rule_label(item.get("label")) + keep_when_bridge_via = item.get("keep_when_bridge_via") is True + if not resource_types or not target_properties or not target_types or label is None: + continue + attachments.append( + CompactChildAttachment( + resource_types=resource_types, + target_properties=target_properties, + target_types=target_types, + label=label, + keep_when_bridge_via=keep_when_bridge_via, + ) + ) + return attachments + + +def _iter_compact_bridge_attachments(raw: Any) -> list[CompactBridgeAttachment]: + if not isinstance(raw, list): + return [] + attachments: list[CompactBridgeAttachment] = [] + for item in raw: + if not isinstance(item, dict): + continue + resource_types = _string_tuple(item.get("resource_types")) + source_properties = _string_tuple(item.get("source_properties")) + via_resource_types = _string_tuple(item.get("via_resource_types")) + via_source_properties = _string_tuple(item.get("via_source_properties")) + via_target_properties = _string_tuple(item.get("via_target_properties")) + target_types = _string_tuple(item.get("target_types")) + label = _rule_label(item.get("label")) + target_self = item.get("target_self") is True + if ( + not resource_types + or not via_resource_types + or not via_source_properties + or (not via_target_properties and not target_self) + or not target_types + or label is None + ): + continue + attachments.append( + CompactBridgeAttachment( + resource_types=resource_types, + source_properties=source_properties, + via_resource_types=via_resource_types, + via_source_properties=via_source_properties, + via_target_properties=via_target_properties, + target_types=target_types, + label=label, + target_self=target_self, + ) + ) + return attachments + + +def _iter_compact_attachment_edges(raw: Any) -> list[CompactAttachmentEdge]: + if not isinstance(raw, list): + return [] + edges: list[CompactAttachmentEdge] = [] + for item in raw: + if not isinstance(item, dict): + continue + resource_types = _string_tuple(item.get("resource_types")) + source_properties = _string_tuple(item.get("source_properties")) + marker_properties = _string_tuple(item.get("marker_properties")) + source_types = _string_tuple(item.get("source_types")) + marker_types = _string_tuple(item.get("marker_types")) + edge_style = item.get("edge_style") + edge_label = _rule_label(item.get("edge_label")) + if not resource_types or not source_properties or not marker_properties or not isinstance(edge_style, str): + continue + edges.append( + CompactAttachmentEdge( + resource_types=resource_types, + source_properties=source_properties, + marker_properties=marker_properties, + source_types=source_types, + marker_types=marker_types, + edge_style=edge_style, + edge_label=edge_label, + ) + ) + return edges + + +def _iter_compact_orchestration_actions(raw: Any) -> list[CompactOrchestrationAction]: + if not isinstance(raw, list): + return [] + actions: list[CompactOrchestrationAction] = [] + for item in raw: + if not isinstance(item, dict): + continue + resource_types = _string_tuple(item.get("resource_types")) + if not resource_types: + continue + actions.append( + CompactOrchestrationAction( + resource_types=resource_types, + command_properties=_string_tuple(item.get("command_properties")), + target_properties=_string_tuple(item.get("target_properties")), + evidence_properties=_string_tuple(item.get("evidence_properties")), + ) + ) + return actions + + +def _iter_compact_concept_nodes(raw: Any) -> list[CompactConceptNode]: + if not isinstance(raw, list): + return [] + nodes: list[CompactConceptNode] = [] + for item in raw: + if not isinstance(item, dict): + continue + via_resource_types = _string_set(item.get("via_resource_types")) + controller_property = item.get("controller_property") + source_property = item.get("source_property") + id_suffix = item.get("id_suffix") + resource_type = item.get("resource_type") + label = _rule_label(item.get("label")) + if ( + not via_resource_types + or not isinstance(controller_property, str) + or not isinstance(source_property, str) + or not isinstance(id_suffix, str) + or not isinstance(resource_type, str) + or label is None + ): + continue + nodes.append( + CompactConceptNode( + via_resource_types=via_resource_types, + controller_property=controller_property, + source_property=source_property, + id_suffix=id_suffix, + resource_type=resource_type, + label=label, + controller_edge=_concept_edge_rule(item.get("controller_edge")), + source_edge=_concept_edge_rule(item.get("source_edge")), + group=_concept_group(item.get("group")), + ) + ) + return nodes + + +def _string_tuple(raw: Any) -> tuple[str, ...]: + if not isinstance(raw, list): + return () + return tuple(item for item in raw if isinstance(item, str)) + + +def _concept_edge_rule(raw: Any) -> ConceptEdgeRule | None: + if not isinstance(raw, dict): + return None + style = raw.get("style") + label = _rule_label(raw.get("label")) + if not isinstance(style, str): + return None + target = raw.get("target") + if target not in {"concept", "controller", "source"}: + target = "concept" + return ConceptEdgeRule(style=style, label=label, target=target) + + +def _concept_group(raw: Any) -> CompactConceptGroup | None: + if not isinstance(raw, dict): + return None + id_suffix = raw.get("id_suffix") + resource_type = raw.get("resource_type") + label = _rule_label(raw.get("label")) + members = _string_tuple(raw.get("members")) + rewrite_edge_kinds = _string_tuple(raw.get("rewrite_edge_kinds")) + if ( + not isinstance(id_suffix, str) + or not isinstance(resource_type, str) + or label is None + or not members + or not rewrite_edge_kinds + ): + return None + return CompactConceptGroup( + id_suffix=id_suffix, + resource_type=resource_type, + label=label, + members=members, + rewrite_edge_kinds=rewrite_edge_kinds, + ) + + +def _rule_label(raw: Any) -> RuleLabel | None: + if isinstance(raw, str): + return raw + if isinstance(raw, dict): + labels = {key: value for key, value in raw.items() if isinstance(key, str) and isinstance(value, str)} + if labels: + return labels + return None diff --git a/src/iac_code/pipeline/engine/architecture_semantic_planning.py b/src/iac_code/pipeline/engine/architecture_semantic_planning.py new file mode 100644 index 00000000..8f9d791c --- /dev/null +++ b/src/iac_code/pipeline/engine/architecture_semantic_planning.py @@ -0,0 +1,5193 @@ +#!/usr/bin/env python3 +"""Preview a ROS template architecture diagram with a real LLM semantic pass. + +Usage: + uv run python scripts/rendering/preview_template_architecture_llm.py TEMPLATE.yml + +The script uses the current iac-code LLM configuration by default. Override it +with IAC_CODE_PROVIDER / IAC_CODE_MODEL / IAC_CODE_API_KEY when needed. +""" + +from __future__ import annotations + +import argparse +import asyncio +import html +import io +import json +import re +import shlex +import shutil +import subprocess +import sys +import tempfile +import time +import webbrowser +from importlib import import_module +from pathlib import Path +from typing import Any, NamedTuple + +from rich.console import Console + +from iac_code.agent.system_prompt import DYNAMIC_BOUNDARY, split_by_dynamic_boundary +from iac_code.config import DEFAULT_MODEL, load_credentials, load_saved_model +from iac_code.i18n import setup_i18n +from iac_code.pipeline.engine.architecture_graph import ( + ArchitectureMultiViewRenderResult, + render_ros_template_architecture, + render_ros_template_architecture_views, +) +from iac_code.providers.base import Message +from iac_code.providers.manager import ProviderManager +from iac_code.ui.diagram_rendering import style_attachment_lines + +MAX_SEMANTIC_PLAN_ATTEMPTS = 3 +RAM_GOVERNANCE_TYPE_PREFIX = "ALIYUN::RAM::" +RAM_GOVERNANCE_CORE_TYPES = { + "ALIYUN::RAM::AccessKey", + "ALIYUN::RAM::Group", + "ALIYUN::RAM::Role", + "ALIYUN::RAM::User", + "ALIYUN::RAM::UserToGroupAddition", +} +RAM_GOVERNANCE_PERMISSION_TYPES = { + "ALIYUN::RAM::AttachPolicyToGroup", + "ALIYUN::RAM::AttachPolicyToRole", + "ALIYUN::RAM::AttachPolicyToUser", + "ALIYUN::RAM::ManagedPolicy", + "ALIYUN::RAM::Policy", + "ALIYUN::RAM::PolicyAttachment", +} + + +class TerminalPreviewItem(NamedTuple): + id: str + title: str + mermaid_source: str + + +SYSTEM_PROMPT = """\ +You enrich ROS architecture diagrams with semantic node labels and edges. +Return ONLY valid JSON, no markdown. + +The JSON schema is: +{"node_labels":[{"id":string,"label":string,"confidence":"high|medium|low"}],"edges":[{"from":string,"to":string,"kind":"traffic|dependency|management|inferred","label":string,"confidence":"high|medium|low"}],"views":[{"id":"overview|detail_","title":string,"purpose":string,"layout":"flat|contained","anchors":[string],"groups":[{"id":string,"label":string,"members":[string],"parent":string}],"nodes":[string],"edges":[{"from":string,"to":string,"kind":"traffic|dependency|management|inferred","label":string}]}]} + +Rules: +- Use only ids from visible_nodes. +- Do not invent resources. +- Use node_label_hints, logical ids, resource types, visible labels, property_references, + all_property_references, route_intents, orchestration_actions, and outputs as naming evidence. +- node_labels replace only the main node title; do not include attachment lines such as "+ EIP" or "+ Security group". +- node label must be short, max 32 chars, preferably a role name such as "vCenter manager" or "ESXi host group". +- Include node_labels only when a clearer role label is useful. +- Omit labels that would be identical to the visible label. +- Omit reason fields and prose explanations. Keep JSON compact. +- Keep the plan compact: at most 24 node_labels and at most 16 edges. +- For complex architectures, produce diagrams as "overview + drill-down details", not parallel perspective views. + The first view must be id="overview": a small end-to-end map that explains the whole architecture with the main + domains/components and the critical relationships between them. It should not repeat every child resource. + The overview should be connected whenever possible: do not put important nodes in overview without an edge that + explains how they participate. Move unconnected components to a detail view or add a high-confidence relationship. +- In overview, use view-only summary groups for equivalent or repeated resources instead of drawing each child as + a separate top-level node. Put groups in the view's groups array, include the group id in nodes, and use the group + id in overview edges and detail anchors. Example: {"id":"ProdAlbGroup","label":"生产 ALB","members":["Alb1","Alb2"]}. + Do not invent group members; every member must be from visible_nodes. Use parent with a container id when the + group belongs inside a VPC/VSwitch/region container. Detail views should expand the real members. +- For networked templates, overview should preserve placement enough to answer "which VPC/VSwitch contains this?". + Prefer layout="contained" for overview when VPC/VSwitch/region placement is important, but keep it small by using + summary groups instead of listing every resource. +- If placement_summary.requires_contained_overview is true, the overview must use layout="contained"; preserve the + VPC/VSwitch placement because it is part of the architecture meaning. +- Add detail views only for complex local areas that need expansion, using ids like detail_dmz, detail_app, + detail_data, detail_network, detail_operations, or detail_permissions. A detail view explains one area from the + overview in more concrete resources and relationships. Each detail view should also be connected whenever possible; + do not list unrelated local resources without relationships. +- Do not create a detail view just to fan out a small summary group that is already clear in overview. For example, + if overview already shows "SLB -> backend server group" and the group label lists two backend servers, skip a + detail_app that only redraws "SLB -> backend server 1" and "SLB -> backend server 2" with the same meaning. +- If overview plus one small detail would still fit in <=8 nodes/groups and <=6 edges, prefer a single overview + instead of creating a drill-down. Small CEN bandwidth/config details can stay in overview when they do not crowd + the layout. +- Every detail view must include anchors: ids from the overview view that this detail expands. If a detail expands + a relationship between two overview nodes, include both as anchors. The renderer marks these anchors in overview + so the user can see which overview part each detail belongs to. +- Choose detail views by local complexity. For example, load balancer plus backend servers becomes detail_app; + CEN/Transit Router/NAT/routes/cross-VPC routing becomes detail_network; database/cache/storage internals become + detail_data; Cloud Assistant/OOS/ESS lifecycle/commands become detail_operations. +- For RAM-heavy governance templates, the primary story is identity and permission governance, not application + runtime traffic. Prioritize users, AccessKeys, groups, roles, policies/permission scopes, and governed resources. + Use detail_permissions, and prefer relationships such as "用户凭证", "加入用户组", "授予权限", "资源范围", + and "角色授权". Keep ECS/RDS/OSS traffic secondary unless the template explicitly describes runtime traffic. + If governance_summary is present, follow its primary_intent and resource_scope_nodes. +- For detail_app that crosses VPCs, make the cross-VPC nature explicit on the edge label, such as "经 CEN 后端转发" + or "跨 VPC 后端转发". If CEN/Transit Router is the actual network path, prefer including it as an intermediate + node or at least name it on the line. Avoid layouts where one ALB appears to fan out to another ALB's ECS backends; + use backend summary groups when fan-out lines become ambiguous. +- Do not use CEN/Transit Router as the target of business traffic. CEN/Transit Router is network underlay for VPC + connectivity, not an application backend. For example, draw NLB -> production ALB/application group as traffic + with a label like "经 CEN 后端转发", and draw separate dependency/management edges from CEN/Transit Router to + VPC/domain/route summary nodes. +- NAT Gateway/SNAT is outbound access, not the public ingress path to NLB/ALB/SLB. Do not draw NAT gateway -> load + balancer as "公网访问" or "公网出口". Show NAT as a VPC egress capability, or connect private/application domains + to NAT with labels such as "SNAT 出网". +- For detail_network, show what the network path is for. Prefer domain nodes or summary groups such as DMZ VPC, + production VPC 1/2, CEN Transit Router, and NAT gateway. Avoid a diagram made mostly of generic "VPC config" or + "route config" nodes; route/config nodes should support a path like "生产 VPC -> CEN -> DMZ NAT". +- For multi-VSwitch architectures, detail_network must actually show VPC/VSwitch/network domain nodes or groups. + Do not create a network detail that only repeats an application or compute anchor. +- Use route_intents to connect routing paths. If a route has next_hop_resource as an ECS instance/group and another + route or CEN route entry points to a CEN attachment, show the forwarding compute as part of the path, such as + "安全 VPC 路由 -> 安全转发网关 -> 安全子网回程路由 -> CEN 转发路由器"; do not leave the + forwarding compute and return route/CEN route on separate isolated branches. +- In detail_network, CEN/Transit Router VPC-connection edges should terminate at VPC/domain/route summary nodes, not + load balancer nodes. Name repeated route/config domains by purpose, such as "DMZ VPC 路由配置", + "生产 VPC 1 路由配置", and "生产 VPC 2 路由配置". +- In overview, do not make CEN/Transit Router the visual source of VPC connection/support edges. A top-down + "CEN/Transit Router -> VPC route domain" edge makes CEN look like the public ingress. Prefer + "VPC/domain/route summary -> CEN/Transit Router" with labels such as "CEN 接入" or "VPC 接入", while business + traffic edges can still say "经 CEN 后端转发". +- In detail_network, also avoid CEN/Transit Router as a traffic source to VPCs or route domains. Reverse those edges + to VPC/domain -> CEN/Transit Router and label them as CEN/VPC access. +- For ACK/Kubernetes templates, use kubernetes_applications and CONCEPT::ACK nodes to express application semantics + instead of leaving Kubernetes manifests as ACK cluster attachment text. Prefer chains such as + Ingress -> Service exposure -> application workload, HPA -> application workload, and metrics/SLS -> HPA when those + nodes exist. +- Keep route/config domain nodes out of overview. Nodes such as "DMZ VPC 路由配置" or "生产 VPC 1 路由域" belong in + detail_network. If a business traffic edge already says "经 CEN", do not also include CEN/Transit Router as an + overview node; anchor detail_network from the business endpoints instead. +- In short: do not also include CEN/Transit Router as an overview node when the traffic label already says "经 CEN". +- In overview, if CEN/Transit Router connects VPCs, do not draw a direct DMZ VPC -> production VPC edge that implies + the VPCs are directly connected. Route the overview relationship through the CEN/Transit Router node. +- Do not create separate peer views named traffic, network, placement, operations, or attachments. Those are + perspectives, not drill-down areas. Network or operations details are allowed only as detail_network or + detail_operations when they expand one local area from the overview. +- Avoid repeating the same central nodes in every view. Repeat a node in a detail view only when it anchors that + local expansion; otherwise keep it in the overview. +- Overview should stay compact: at most 8 nodes and 6 edges. Detail views should stay local: at most 12 nodes and + 8 edges. Put the key relationships in either overview or the relevant detail; do not delete relationships merely + to make diagrams cleaner. +- Use layout="flat" for overview and most detail views so containment does not make terminal diagrams too tall. + Use layout="contained" only for a detail view whose purpose is physical placement or boundary expansion, such as + a VPC/VSwitch, region, security boundary, or network segment. +- Do not encode VPC/VSwitch/SecurityGroup containment as edges. +- edge label must be short, max 18 chars, preferably 1-3 words. +- Terminal rendering does not support multiline edge labels. For orchestration_actions, include the source in + parentheses instead of using a newline, for example "挂载 NAS（云助手）". +- Follow target_language from the fact bundle. Use short Chinese role labels when target_language.code is "zh". +- Do not copy raw identifier-like names such as "APP01" or "ALB_HZ_1" as final labels in Chinese output. Treat + node_label_hints as evidence for role and sequence, not as display text, unless the name is already a human + business name in the target language. +- Product acronyms such as ECS, ALB, NLB, CEN, VPC, NAT, Redis, and PolarDB may remain, but the label should still + carry target-language role meaning, for example "生产 ALB 1" or "应用服务器 1". +- Use explicit_relations, property_references, and all_property_references as evidence for dependencies, including + references embedded in UserData. explicit_relations may include hidden folded resources such as Route resources. + Treat ALIYUN::ECS::Route.NextHopId and CEN route-entry next-hop relations as routing-path evidence, and infer + edges only between visible nodes. +- Use network_attachments as evidence for CEN/cross-VPC underlay. For ALIYUN::CEN::CenInstanceAttachment, + child_instance_type=VPC/VBR means the CEN instance connects a VPC or VBR; child_resource identifies a resource + created in this template, while Ref:* child ids are existing external networks. +- Do not leave CEN/network access configuration isolated in overview. If it matters to the end-to-end story, connect + it to the relevant VPC/domain/application path; otherwise keep it in detail_network. +- For detail_network with CEN/VPC/VBR relationships, prefer flat VPC/domain summary nodes over contained VPC + containers when the VPC contains application servers. Contained VPC layout expands the business resources and makes + a network interconnect diagram look like an application placement diagram. +- When network_attachments has a child_resource such as "Vpc", include that resource/container as a flat node in + detail_network and connect it to the CEN/network access config with a label like "CEN 接入". Existing external + Ref:* VPC/VBR ids may stay summarized inside the CEN config label when no visible node exists. +- When CEN attachments include external Ref:* VPC/VBR ids, make that explicit in detail_network. Do not draw only + "current VPC -> CEN config"; label the CEN config or edge as current VPC plus external VPC/VBR interconnect, such + as "CEN 互联（外部网络 x2）" or "与外部 VPC/VBR 互联". +- Use orchestration_actions as evidence for intent edges from target compute resources to referenced resources. + Do not render the orchestration action itself as a node. +- If one orchestration action targets multiple compute resources and references the same databases, caches, message + queues, registries, or storage endpoints, show those as shared application dependencies. Use a summary group or + mirror the dependency edges; do not attach the backend dependencies to only one target. +- When an ESS scaling configuration is derived from a seed/template ECS instance, either directly or through a custom + image made from that instance, render the configuration-source relationship from the ECS instance to the ESS scaling + group, not from the scaling group back to the seed instance. Use a short label such as "伸缩配置" or + "scaling config". +- If concept_nodes contains scaled compute instances, put inherited application traffic on that concept node, + not on the scaling controller. +- Use inferred/low for plausible app dependencies not explicitly present in the template. +- Use management for configuration, orchestration, scaling, or attachment relationships. +- Prefer a small number of useful edges over a dense graph. +- Avoid repeated fan-in or fan-out edges between equivalent resources. If several equivalent resources share the same + relationship, use one aggregate relationship to a concept/group node when available, or keep the relationship + summarized in the role labels instead of drawing every parallel edge. +""" + +HTML_TEMPLATE = """\ + + + + +{title} + + + + +
+

{title}

+ 
+{mermaid}
+
+
+ + + +""" + +PROMPT_DEBUG_HTML_TEMPLATE = """\ + + + + +{title} + + + +

{title}

+
Model: {model}
+
Generated at: {generated_at}
+
+

Summary

+
{metrics}
+ + + + + + + + + + + + + + + {rows} +
AttemptSelectedLLM TimePrompt CharsCache Prefix CharsSent IssuesResult IssuesCache Read TokensRaw Output Chars
+
+ {attempts} + + +""" + + +def build_semantic_plan_user_prompt( + architecture_context: dict[str, Any], + *, + attempt: int | None = None, + previous_plan: dict[str, Any] | None = None, + validation_issues: list[str] | tuple[str, ...] = (), + include_fact_bundle: bool = True, + include_previous_plan: bool = True, +) -> str: + fact_bundle = json.dumps(architecture_context, ensure_ascii=False, separators=(",", ":")) + attempt_prefix = f"Attempt {attempt} instruction" if attempt is not None else "Attempt instruction" + if validation_issues: + issues = "\n".join(f"- {issue}" for issue in validation_issues) + previous = json.dumps(previous_plan or {}, ensure_ascii=False, indent=2) + previous_section = "" + if include_previous_plan: + previous_section = f"\n\nPrevious semantic_plan:\n{previous}" + dynamic_instruction = ( + f"{attempt_prefix}:\n" + "Revise the previous semantic_plan for this architecture fact bundle.\n" + "Fix every validation issue below. Return JSON only.\n\n" + "Validation issues:\n" + f"{issues}" + f"{previous_section}\n\n" + "Return JSON only." + ) + else: + dynamic_instruction = ( + f"{attempt_prefix}:\n" + "Create a semantic_plan for this architecture fact bundle.\n" + "Follow target_language exactly. Return JSON only." + ) + if not include_fact_bundle: + return dynamic_instruction + return f"Architecture fact bundle:\n{fact_bundle}\n\n{DYNAMIC_BOUNDARY}\n\n{dynamic_instruction}" + + +def extract_semantic_plan_json(text: str) -> dict[str, Any]: + content = text.strip() + if content.startswith("```"): + content = re.sub(r"^```(?:json)?\s*", "", content) + content = re.sub(r"\s*```$", "", content) + try: + value = json.loads(content) + except json.JSONDecodeError: + match = re.search(r"\{.*\}", content, re.S) + if match is None: + raise ValueError("LLM output does not contain a JSON object") from None + value = json.loads(match.group(0)) + if not isinstance(value, dict): + raise ValueError("LLM output JSON must be an object") + return value + + +def try_extract_semantic_plan_json(text: str) -> tuple[dict[str, Any] | None, str | None]: + try: + return extract_semantic_plan_json(text), None + except Exception as exc: + return None, f"{type(exc).__name__}: {exc}" + + +def build_llm_architecture_context(architecture_context: dict[str, Any]) -> dict[str, Any]: + """Build the smaller fact bundle sent to the LLM. + + Rendering and validation still use the full architecture context. This is + only the semantic prompt payload, so it keeps evidence that helps naming and + relationships while dropping rendered-state/debug data. + """ + list_limits = { + "visible_edges": 80, + "explicit_relations": 96, + "property_references": 48, + "all_property_references": 64, + "route_intents": 64, + "network_attachments": 64, + "kubernetes_applications": 80, + "orchestration_actions": 64, + "outputs": 32, + "node_label_hints": 80, + } + keep_keys = ( + "template_summary", + "target_language", + "visible_nodes", + "concept_nodes", + "containers", + "containment", + "visible_edges", + "explicit_relations", + "property_references", + "all_property_references", + "route_intents", + "network_attachments", + "kubernetes_applications", + "node_label_hints", + "orchestration_actions", + "outputs", + "llm_semantic_plan_schema", + ) + slim: dict[str, Any] = {} + truncation_summary: dict[str, dict[str, int | bool]] = {} + for key in keep_keys: + if key not in architecture_context: + continue + value = architecture_context[key] + if isinstance(value, list) and key in list_limits: + limit = list_limits[key] + slim[key] = value[:limit] + total_count = len(value) + if total_count > limit: + truncation_summary[key] = { + "included_count": limit, + "total_count": total_count, + "omitted_count": total_count - limit, + "truncated": True, + } + else: + slim[key] = value + if truncation_summary: + slim["truncation_summary"] = truncation_summary + governance_summary = _build_governance_summary(architecture_context) + if governance_summary: + slim["governance_summary"] = governance_summary + placement_summary = _build_placement_summary(architecture_context) + if placement_summary: + slim["placement_summary"] = placement_summary + slim["semantic_plan_scaffold"] = _build_semantic_plan_scaffold(architecture_context) + return slim + + +def _build_semantic_plan_scaffold(architecture_context: dict[str, Any]) -> dict[str, Any]: + raw_edges: list[dict[str, Any]] = [] + overview_layout = ( + "contained" + if _needs_network_drilldown_view(architecture_context) + or _needs_placement_preserving_overview(architecture_context) + else "flat" + ) + needs_ram_governance = _needs_ram_governance_drilldown_view(architecture_context) + needs_ack_application = _needs_ack_application_drilldown_view(architecture_context) + views = [ + { + "id": "overview", + "layout": overview_layout, + "max_nodes": 8, + "max_edges": 6, + "intent": "end-to-end summary; use summary groups for repeated resources", + } + ] + if needs_ram_governance: + views.append( + { + "id": "detail_permissions", + "layout": "flat", + "max_nodes": 12, + "max_edges": 8, + "intent": "expand RAM users, AccessKeys, groups, roles, policies, and governed resource scopes", + } + ) + if _needs_network_drilldown_view(architecture_context): + views.append( + { + "id": "detail_network", + "layout": "flat", + "max_nodes": 12, + "max_edges": 8, + "intent": "expand CEN/TransitRouter/NAT/routes/cross-VPC relationships from overview anchors", + } + ) + resource_types = { + str(item.get("type") or "") + for item in _list_of_dicts(architecture_context.get("visible_nodes")) + if item.get("type") + } + if not needs_ram_governance and ( + needs_ack_application + or any("LoadBalancer" in resource_type or "::ECS::" in resource_type for resource_type in resource_types) + ): + views.append( + { + "id": "detail_app", + "layout": "flat", + "max_nodes": 12, + "max_edges": 8, + "intent": ( + "expand ACK/Kubernetes ingress/service/HPA/workload relationships from overview anchors" + if needs_ack_application + else "expand ingress/load-balancer/application compute relationships from overview anchors" + ), + } + ) + if not needs_ram_governance and any( + marker in resource_type + for resource_type in resource_types + for marker in ("POLARDB", "RDS", "REDIS", "NAS", "OSS", "DBInstance", "DBCluster") + ): + views.append( + { + "id": "detail_data", + "layout": "flat", + "max_nodes": 12, + "max_edges": 8, + "intent": "expand database/cache/storage access relationships from overview anchors", + } + ) + if _list_of_dicts(architecture_context.get("orchestration_actions")): + views.append( + { + "id": "detail_operations", + "layout": "flat", + "max_nodes": 12, + "max_edges": 8, + "intent": "expand Cloud Assistant/OOS/ESS lifecycle operations from overview anchors", + } + ) + return {"views": views[:4], "edge_budget": 16, "node_label_budget": 24, "raw_edges": raw_edges} + + +def _build_governance_summary(architecture_context: dict[str, Any]) -> dict[str, Any]: + if not _needs_ram_governance_drilldown_view(architecture_context): + return {} + visible_ram_nodes = [ + _summary_node(item) + for item in _list_of_dicts(architecture_context.get("visible_nodes")) + if _semantic_type_is_ram_governance(str(item.get("type") or "")) + ] + resource_scope_nodes = [ + _summary_node(item) + for item in _list_of_dicts(architecture_context.get("visible_nodes")) + if not _semantic_type_is_ram_governance(str(item.get("type") or "")) + ] + ram_counts: dict[str, int] = {} + for item in _ram_governance_items(architecture_context): + resource_type = str(item.get("type") or "") + short_type = resource_type.rsplit("::", 1)[-1] if resource_type else "Unknown" + ram_counts[short_type] = ram_counts.get(short_type, 0) + 1 + return { + "primary_intent": "identity_and_permission_governance", + "ram_counts": dict(sorted(ram_counts.items())), + "ram_visible_nodes": visible_ram_nodes[:12], + "resource_scope_nodes": resource_scope_nodes[:12], + "recommended_view": "detail_permissions", + "relationship_intents": [ + "AccessKey -> RAM User", + "RAM User -> RAM Group", + "RAM Group/Role -> permission scope resources", + "RAM Role -> compute/service assuming the role", + ], + } + + +def _build_placement_summary(architecture_context: dict[str, Any]) -> dict[str, Any]: + if not _needs_placement_preserving_overview(architecture_context): + return {} + return { + "primary_intent": "multi_vswitch_or_availability_zone_placement", + "requires_contained_overview": True, + "placement_domains": _placement_vswitch_domains(architecture_context)[:8], + "relationship_intents": [ + "show which application/data resources are placed in each VSwitch", + "preserve VPC/VSwitch boundaries in overview", + "keep SLB/application/database traffic edges inside the contained overview", + ], + } + + +def _summary_node(item: dict[str, Any]) -> dict[str, str]: + summary: dict[str, str] = {} + for key in ("id", "type", "label"): + value = item.get(key) + if isinstance(value, str) and value: + summary[key] = value + return summary + + +def repair_semantic_plan_locally(architecture_context: dict[str, Any], semantic_plan: dict[str, Any]) -> dict[str, Any]: + valid_node_ids = { + str(item.get("id")) + for item in _list_of_dicts(architecture_context.get("visible_nodes")) + if isinstance(item.get("id"), str) + } + valid_container_ids = { + str(item.get("id")) + for item in _list_of_dicts(architecture_context.get("containers")) + if isinstance(item.get("id"), str) + } + valid_real_ids = valid_node_ids | valid_container_ids + repaired: dict[str, Any] = {} + + node_labels: list[dict[str, Any]] = [] + for label in _list_of_dicts(semantic_plan.get("node_labels")): + node_id = label.get("id") + text = label.get("label") + if not isinstance(node_id, str) or node_id not in valid_node_ids: + continue + if not isinstance(text, str) or not text.strip(): + continue + cleaned: dict[str, Any] = {"id": node_id, "label": _single_line_label(text, 32)} + confidence = label.get("confidence") + if isinstance(confidence, str) and confidence in {"high", "medium", "low"}: + cleaned["confidence"] = confidence + node_labels.append(cleaned) + if len(node_labels) >= 24: + break + if node_labels: + repaired["node_labels"] = node_labels + + edges = _repair_semantic_edges( + _list_of_dicts(semantic_plan.get("edges")), + valid_node_ids, + max_edges=16, + require_selected_ids=None, + ) + if edges: + repaired["edges"] = edges + + views = _repair_semantic_views( + architecture_context, + _list_of_dicts(semantic_plan.get("views")), + valid_real_ids, + valid_node_ids, + ) + if views: + views = _replace_noisy_container_overview_with_business_edges(architecture_context, views, edges) + views = _complete_overview_with_top_level_edges(architecture_context, views, edges) + views = _repair_external_cen_network_view_edges(architecture_context, views) + views = _drop_nat_to_load_balancer_edges_from_views(architecture_context, views) + views = _repair_transit_router_source_edges_from_views(architecture_context, views) + views = _repair_split_route_forwarder_chain_edges(architecture_context, views) + views = _repair_cross_network_detail_edge_labels(architecture_context, views) + views = _drop_redundant_detail_views(views) + views = _merge_small_detail_views_into_overview(architecture_context, views) + views = _drop_redundant_attachment_marker_nodes_from_views(architecture_context, views) + views = _drop_empty_overview_containers_from_views(architecture_context, views) + views = _complete_detail_views_from_overview_edges(views) + views = _drop_redundant_detail_views(views) + views = _drop_isolated_non_anchor_detail_nodes_from_views(views) + repaired["views"] = views + return repaired + + +def _replace_noisy_container_overview_with_business_edges( + architecture_context: dict[str, Any], + views: list[dict[str, Any]], + top_level_edges: list[dict[str, Any]], +) -> list[dict[str, Any]]: + if not top_level_edges: + return views + visible_node_ids = { + str(item.get("id")) + for item in _list_of_dicts(architecture_context.get("visible_nodes")) + if isinstance(item.get("id"), str) + } + network_container_ids = { + str(item.get("id")) + for item in _list_of_dicts(architecture_context.get("containers")) + if isinstance(item.get("id"), str) and str(item.get("type") or "") == "ALIYUN::ECS::VSwitch" + } + if not visible_node_ids or not network_container_ids: + return views + + replacement_overview: dict[str, Any] | None = None + replacement_nodes: list[str] = [] + replacement_edges: list[dict[str, Any]] = [] + for view in views: + if str(view.get("id") or "") != "overview": + continue + nodes = _dedupe_strings(view.get("nodes")) + if len([node_id for node_id in nodes if node_id in network_container_ids]) < 3: + continue + groups = _list_of_dicts(view.get("groups")) + group_ids = {str(group.get("id")) for group in groups if isinstance(group.get("id"), str)} + if groups or any(node_id in visible_node_ids or node_id in group_ids for node_id in nodes): + continue + replacement_nodes = _top_level_edge_endpoint_nodes(top_level_edges, visible_node_ids) + if len(replacement_nodes) < 2: + continue + replacement_edges = _top_level_edges_between_nodes(top_level_edges, set(replacement_nodes)) + if not replacement_edges: + continue + replacement_overview = { + **view, + "nodes": replacement_nodes[:8], + "edges": replacement_edges[:8], + } + replacement_overview.pop("groups", None) + break + + if replacement_overview is None: + return views + + replacement_node_ids = set(replacement_nodes) + container_replacements = _overview_container_anchor_replacements( + architecture_context, + replacement_nodes, + ) + repaired_views: list[dict[str, Any]] = [] + for view in views: + if str(view.get("id") or "") == "overview": + repaired_views.append(replacement_overview) + continue + repaired_view = dict(view) + anchors = _dedupe_strings(view.get("anchors")) + if anchors: + repaired_anchors: list[str] = [] + for anchor_id in anchors: + if anchor_id in replacement_node_ids: + repaired_anchors.append(anchor_id) + continue + repaired_anchors.extend(container_replacements.get(anchor_id, [])) + repaired_anchors = _dedupe_strings(repaired_anchors) + if repaired_anchors: + repaired_view["anchors"] = repaired_anchors + else: + repaired_view.pop("anchors", None) + repaired_views.append(repaired_view) + return repaired_views + + +def _top_level_edge_endpoint_nodes(top_level_edges: list[dict[str, Any]], visible_node_ids: set[str]) -> list[str]: + endpoint_nodes: list[str] = [] + for edge in top_level_edges: + for endpoint_key in ("from", "to"): + endpoint_id = _semantic_edge_endpoint(edge, endpoint_key) + if endpoint_id in visible_node_ids: + endpoint_nodes.append(endpoint_id) + return _dedupe_strings(endpoint_nodes) + + +def _top_level_edges_between_nodes( + top_level_edges: list[dict[str, Any]], + selected_node_ids: set[str], +) -> list[dict[str, Any]]: + repaired_edges: list[dict[str, Any]] = [] + seen: set[tuple[str, str, str, str]] = set() + for edge in top_level_edges: + from_id = _semantic_edge_endpoint(edge, "from") + to_id = _semantic_edge_endpoint(edge, "to") + if from_id not in selected_node_ids or to_id not in selected_node_ids: + continue + repaired_edge = { + "from": from_id, + "to": to_id, + "kind": str(edge.get("kind") or "inferred"), + "label": str(edge.get("label") or ""), + } + edge_key = ( + str(repaired_edge["from"]), + str(repaired_edge["to"]), + str(repaired_edge["kind"]), + str(repaired_edge["label"]), + ) + if edge_key in seen: + continue + repaired_edges.append(repaired_edge) + seen.add(edge_key) + return repaired_edges + + +def _overview_container_anchor_replacements( + architecture_context: dict[str, Any], + overview_node_ids: list[str], +) -> dict[str, list[str]]: + containment_parent = { + str(item.get("resource")): str(item.get("container")) + for item in _list_of_dicts(architecture_context.get("containment")) + if isinstance(item.get("resource"), str) and isinstance(item.get("container"), str) + } + container_parent = { + str(item.get("id")): str(item.get("parent")) + for item in _list_of_dicts(architecture_context.get("containers")) + if isinstance(item.get("id"), str) and isinstance(item.get("parent"), str) + } + replacements: dict[str, list[str]] = {} + for node_id in overview_node_ids: + current = containment_parent.get(node_id) + visited: set[str] = set() + while current and current not in visited: + visited.add(current) + replacements.setdefault(current, []).append(node_id) + current = container_parent.get(current) + return {container_id: _dedupe_strings(node_ids) for container_id, node_ids in replacements.items()} + + +def _complete_overview_with_top_level_edges( + architecture_context: dict[str, Any], + views: list[dict[str, Any]], + top_level_edges: list[dict[str, Any]], +) -> list[dict[str, Any]]: + if not top_level_edges: + return views + visible_node_types = _visible_node_types_by_id(architecture_context) + has_detail_network = any(str(view.get("id") or "") == "detail_network" for view in views) + repaired_views: list[dict[str, Any]] = [] + for view in views: + if str(view.get("id") or "") != "overview": + repaired_views.append(view) + continue + nodes = _dedupe_strings(view.get("nodes")) + groups = _list_of_dicts(view.get("groups")) + group_ids = {str(group.get("id")) for group in groups if isinstance(group.get("id"), str)} + selected_ids = set(nodes) | group_ids + selected_group_members: set[str] = set() + for group in groups: + group_id = group.get("id") + if isinstance(group_id, str) and group_id in selected_ids: + selected_group_members.update(_dedupe_strings(group.get("members"))) + view_edges = _list_of_dicts(view.get("edges")) + edge_keys = { + ( + _semantic_edge_endpoint(edge, "from"), + _semantic_edge_endpoint(edge, "to"), + str(edge.get("kind") or ""), + str(edge.get("label") or ""), + ) + for edge in view_edges + } + connected_ids = _edge_endpoint_ids(view_edges) + repaired_edges = list(view_edges) + for edge in top_level_edges: + from_id = _semantic_edge_endpoint(edge, "from") + to_id = _semantic_edge_endpoint(edge, "to") + if from_id is None or to_id is None: + continue + if has_detail_network and ( + _semantic_endpoint_is_network_route_config_detail(from_id, visible_node_types) + or _semantic_endpoint_is_network_route_config_detail(to_id, visible_node_types) + ): + continue + if from_id not in selected_ids and to_id not in selected_ids: + continue + missing_ids = [node_id for node_id in (from_id, to_id) if node_id not in selected_ids] + if any(node_id in selected_group_members for node_id in missing_ids): + continue + connects_isolated_selected_node = not missing_ids and ( + from_id not in connected_ids or to_id not in connected_ids + ) + edge_limit = 8 if connects_isolated_selected_node else 6 + if len(nodes) + len(missing_ids) > 8 or len(repaired_edges) >= edge_limit: + continue + for node_id in missing_ids: + nodes.append(node_id) + selected_ids.add(node_id) + edge_key = (from_id, to_id, str(edge.get("kind") or ""), str(edge.get("label") or "")) + if edge_key in edge_keys: + continue + repaired_edges.append( + { + "from": from_id, + "to": to_id, + "kind": str(edge.get("kind") or "inferred"), + "label": str(edge.get("label") or ""), + } + ) + edge_keys.add(edge_key) + connected_ids.add(from_id) + connected_ids.add(to_id) + repaired_views.append({**view, "nodes": nodes, "edges": repaired_edges}) + return repaired_views + + +def _drop_empty_overview_containers_from_views( + architecture_context: dict[str, Any], + views: list[dict[str, Any]], +) -> list[dict[str, Any]]: + container_ids = { + str(item.get("id")) + for item in _list_of_dicts(architecture_context.get("containers")) + if isinstance(item.get("id"), str) + } + if not container_ids: + return views + containment_parent = { + str(item.get("resource")): str(item.get("container")) + for item in _list_of_dicts(architecture_context.get("containment")) + if isinstance(item.get("resource"), str) and isinstance(item.get("container"), str) + } + container_parent = { + str(item.get("id")): str(item.get("parent")) + for item in _list_of_dicts(architecture_context.get("containers")) + if isinstance(item.get("id"), str) and isinstance(item.get("parent"), str) + } + + repaired_views: list[dict[str, Any]] = [] + for view in views: + if str(view.get("id") or "") != "overview": + repaired_views.append(view) + continue + nodes = _dedupe_strings(view.get("nodes")) + if not any(node_id in container_ids for node_id in nodes): + repaired_views.append(view) + continue + selected_ids = set(nodes) + connected_ids: set[str] = set() + for edge in _list_of_dicts(view.get("edges")): + from_id = _semantic_edge_endpoint(edge, "from") + to_id = _semantic_edge_endpoint(edge, "to") + if from_id in selected_ids: + connected_ids.add(from_id) + if to_id in selected_ids: + connected_ids.add(to_id) + groups = _list_of_dicts(view.get("groups")) + repaired_nodes = [ + node_id + for node_id in nodes + if node_id not in container_ids + or node_id in connected_ids + or _overview_container_has_selected_real_child( + node_id, + selected_ids - container_ids, + containment_parent, + container_parent, + ) + or _overview_container_has_selected_group_parent(node_id, selected_ids, groups, container_parent) + ] + repaired_views.append({**view, "nodes": repaired_nodes}) + return repaired_views + + +def _overview_container_has_selected_real_child( + container_id: str, + selected_node_ids: set[str], + containment_parent: dict[str, str], + container_parent: dict[str, str], +) -> bool: + for selected_node_id in selected_node_ids: + parent_id = containment_parent.get(selected_node_id) + if parent_id and _semantic_container_is_descendant_or_same(parent_id, container_id, container_parent): + return True + return False + + +def _overview_container_has_selected_group_parent( + container_id: str, + selected_ids: set[str], + groups: list[dict[str, Any]], + container_parent: dict[str, str], +) -> bool: + for group in groups: + group_id = group.get("id") + parent_id = group.get("parent") + if ( + isinstance(group_id, str) + and group_id in selected_ids + and isinstance(parent_id, str) + and _semantic_container_is_descendant_or_same(parent_id, container_id, container_parent) + ): + return True + return False + + +def _drop_isolated_non_anchor_detail_nodes_from_views(views: list[dict[str, Any]]) -> list[dict[str, Any]]: + repaired_views: list[dict[str, Any]] = [] + for view in views: + view_id = str(view.get("id") or "") + view_edges = _list_of_dicts(view.get("edges")) + if not view_id.startswith("detail_") or not view_edges: + repaired_views.append(view) + continue + edge_endpoints: set[str] = set() + for edge in view_edges: + from_id = _semantic_edge_endpoint(edge, "from") + to_id = _semantic_edge_endpoint(edge, "to") + if from_id is not None: + edge_endpoints.add(from_id) + if to_id is not None: + edge_endpoints.add(to_id) + anchors = set(_dedupe_strings(view.get("anchors"))) + nodes = _dedupe_strings(view.get("nodes")) + kept_nodes = [node_id for node_id in nodes if node_id in edge_endpoints or node_id in anchors] + if kept_nodes == nodes: + repaired_views.append(view) + continue + repaired_view = dict(view) + repaired_view["nodes"] = kept_nodes + repaired_views.append(repaired_view) + return repaired_views + + +def _repair_external_cen_network_view_edges( + architecture_context: dict[str, Any], + views: list[dict[str, Any]], +) -> list[dict[str, Any]]: + external_attachments = _semantic_external_cen_network_attachments(architecture_context) + if not external_attachments: + return views + attached_child_resources = { + str(attachment.get("child_resource")) + for attachment in _list_of_dicts(architecture_context.get("network_attachments")) + if attachment.get("type") == "ALIYUN::CEN::CenInstanceAttachment" + and isinstance(attachment.get("child_resource"), str) + and str(attachment.get("child_resource")).strip() + } + if not attached_child_resources: + return views + cen_config_ids = _semantic_selected_cen_config_ids( + architecture_context, + { + str(item.get("id")) + for item in _list_of_dicts(architecture_context.get("visible_nodes")) + if isinstance(item.get("id"), str) + }, + ) + if not cen_config_ids: + return views + replacement_label = _external_cen_network_edge_label(external_attachments) + repaired_views: list[dict[str, Any]] = [] + for view in views: + repaired_edges: list[dict[str, Any]] = [] + for edge in _list_of_dicts(view.get("edges")): + from_id = _semantic_edge_endpoint(edge, "from") + to_id = _semantic_edge_endpoint(edge, "to") + label = str(edge.get("label") or "") + connects_local_child_to_cen = ( + from_id in attached_child_resources + and to_id in cen_config_ids + or to_id in attached_child_resources + and from_id in cen_config_ids + ) + if connects_local_child_to_cen and not _semantic_text_mentions_external_cen_network(label): + edge = {**edge, "label": replacement_label} + repaired_edges.append(edge) + repaired_views.append({**view, "edges": repaired_edges}) + return repaired_views + + +def _external_cen_network_edge_label(external_attachments: list[dict[str, Any]]) -> str: + child_types = { + str(attachment.get("child_instance_type") or "").upper() + for attachment in external_attachments + if attachment.get("child_instance_type") + } + if "VPC" in child_types and "VBR" in child_types: + return "连接外部VPC/VBR" + if "VBR" in child_types: + return "连接外部VBR" + if "VPC" in child_types: + return "连接外部VPC" + return "连接外部网络" + + +def _drop_nat_to_load_balancer_edges_from_views( + architecture_context: dict[str, Any], + views: list[dict[str, Any]], +) -> list[dict[str, Any]]: + visible_node_types = { + str(item.get("id")): str(item.get("type") or "") + for item in _list_of_dicts(architecture_context.get("visible_nodes")) + if isinstance(item.get("id"), str) + } + repaired_views: list[dict[str, Any]] = [] + for view in views: + group_members = _semantic_view_group_members(view) + group_parents = _semantic_view_group_parents(view) + kept_edges: list[dict[str, Any]] = [] + dropped_nat_ids: set[str] = set() + for edge in _list_of_dicts(view.get("edges")): + from_id = _semantic_edge_endpoint(edge, "from") + to_id = _semantic_edge_endpoint(edge, "to") + if from_id is None or to_id is None: + continue + if _semantic_edge_connects_nat_and_load_balancer( + from_id, + to_id, + visible_node_types, + group_members, + group_parents, + ): + nat_endpoint = _semantic_nat_endpoint_id( + from_id, + to_id, + visible_node_types, + group_members, + group_parents, + ) + if nat_endpoint is not None: + dropped_nat_ids.add(nat_endpoint) + continue + kept_edges.append(edge) + if not dropped_nat_ids: + repaired_views.append(view) + continue + repaired_view = {**view, "edges": kept_edges} + if str(view.get("id") or "") == "overview": + connected_ids = _edge_endpoint_ids(kept_edges) + repaired_view["nodes"] = [ + node_id + for node_id in _dedupe_strings(view.get("nodes")) + if node_id not in dropped_nat_ids or node_id in connected_ids + ] + repaired_views.append(repaired_view) + return repaired_views + + +def _repair_transit_router_source_edges_from_views( + architecture_context: dict[str, Any], + views: list[dict[str, Any]], +) -> list[dict[str, Any]]: + endpoint_types = { + str(item.get("id")): str(item.get("type") or "") + for item in [ + *_list_of_dicts(architecture_context.get("visible_nodes")), + *_list_of_dicts(architecture_context.get("containers")), + ] + if isinstance(item.get("id"), str) + } + repaired_views: list[dict[str, Any]] = [] + for view in views: + if str(view.get("id") or "") != "detail_network": + repaired_views.append(view) + continue + repaired_edges: list[dict[str, Any]] = [] + for edge in _list_of_dicts(view.get("edges")): + from_id = _semantic_edge_endpoint(edge, "from") + to_id = _semantic_edge_endpoint(edge, "to") + if from_id is None or to_id is None: + continue + label = str(edge.get("label") or "") + kind = str(edge.get("kind") or "") + if ( + _semantic_endpoint_is_transit_router(from_id, endpoint_types) + and not _semantic_endpoint_is_transit_router(to_id, endpoint_types) + and (kind == "traffic" or _semantic_label_mentions_vpc_connection(label) or "路由" in label) + ): + if _find_existing_edge_index(repaired_edges, to_id, from_id) is None: + repaired_edges.append( + { + "from": to_id, + "to": from_id, + "kind": "dependency", + "label": "CEN 接入", + } + ) + continue + repaired_edges.append(edge) + repaired_views.append({**view, "edges": repaired_edges}) + return repaired_views + + +def _repair_split_route_forwarder_chain_edges( + architecture_context: dict[str, Any], + views: list[dict[str, Any]], +) -> list[dict[str, Any]]: + if not _list_of_dicts(architecture_context.get("network_attachments")): + return views + forwarder_ids = _semantic_route_next_hop_compute_ids(architecture_context) + if not forwarder_ids: + return views + visible_node_types = { + str(item.get("id")): str(item.get("type") or "") + for item in _list_of_dicts(architecture_context.get("visible_nodes")) + if isinstance(item.get("id"), str) + } + + repaired_views: list[dict[str, Any]] = [] + for view in views: + if str(view.get("id") or "") != "detail_network": + repaired_views.append(view) + continue + + selected_ids = _semantic_view_selected_ids(view) + selected_forwarders = sorted(forwarder_ids & selected_ids) + transit_ids = { + selected_id + for selected_id in selected_ids + if _semantic_endpoint_is_transit_router(selected_id, visible_node_types) + } + if not selected_forwarders or not transit_ids: + repaired_views.append(view) + continue + + repaired_edges = [dict(edge) for edge in _list_of_dicts(view.get("edges"))] + cen_route_config_ids = _semantic_route_config_ids_adjacent_to_targets( + selected_ids, + transit_ids, + repaired_edges, + visible_node_types, + ) + route_config_ids = _semantic_return_route_config_target_ids( + selected_ids, + cen_route_config_ids, + repaired_edges, + visible_node_types, + ) + changed = False + for forwarder_id in selected_forwarders: + target_id = _first_disconnected_route_chain_target( + forwarder_id, + route_config_ids, + set(), + repaired_edges, + ) + if target_id is None: + if _semantic_view_has_path(forwarder_id, transit_ids, repaired_edges): + continue + target_id = _first_disconnected_route_chain_target( + forwarder_id, + [], + transit_ids, + repaired_edges, + ) + if target_id is None or _find_existing_edge_index(repaired_edges, forwarder_id, target_id) is not None: + continue + repaired_edges.append( + { + "from": forwarder_id, + "to": target_id, + "kind": "dependency", + "label": "回程路由" if target_id in route_config_ids else "转发至 CEN", + } + ) + changed = True + if len(repaired_edges) >= 8: + break + if changed: + repaired_views.append({**view, "edges": repaired_edges[:8]}) + else: + repaired_views.append(view) + return repaired_views + + +def _repair_cross_network_detail_edge_labels( + architecture_context: dict[str, Any], + views: list[dict[str, Any]], +) -> list[dict[str, Any]]: + visible_node_types = _visible_node_types_by_id(architecture_context) + containment_parent = _semantic_resource_container_map(architecture_context) + container_parent = _semantic_container_parent_map(architecture_context) + repaired_views: list[dict[str, Any]] = [] + for view in views: + if str(view.get("id") or "") != "detail_network": + repaired_views.append(view) + continue + selected_ids = _semantic_view_selected_ids(view) + if not _semantic_view_has_transit_router(selected_ids, visible_node_types): + repaired_views.append(view) + continue + group_members = _semantic_view_group_members(view) + group_parents = _semantic_view_group_parents(view) + repaired_edges: list[dict[str, Any]] = [] + changed = False + for edge in _list_of_dicts(view.get("edges")): + from_id = _semantic_edge_endpoint(edge, "from") + to_id = _semantic_edge_endpoint(edge, "to") + label = str(edge.get("label") or "") + if ( + from_id is not None + and to_id is not None + and label + and not _semantic_label_mentions_cross_network(label) + and _semantic_edge_crosses_network_domains( + from_id, + to_id, + visible_node_types, + containment_parent, + container_parent, + group_members, + group_parents, + ) + ): + edge = {**edge, "label": _prefix_cen_edge_label(label)} + changed = True + repaired_edges.append(edge) + repaired_views.append({**view, "edges": repaired_edges} if changed else view) + return repaired_views + + +def _prefix_cen_edge_label(label: str) -> str: + cleaned = _single_line_label(label, 14).strip() + if not cleaned: + return "经 CEN" + if _semantic_label_mentions_cross_network(cleaned): + return cleaned + return _single_line_label(f"经 CEN {cleaned}", 18) + + +def _semantic_route_config_ids_adjacent_to_targets( + selected_ids: set[str], + target_ids: set[str], + view_edges: list[dict[str, Any]], + visible_node_types: dict[str, str], +) -> list[str]: + route_config_ids: list[str] = [] + seen: set[str] = set() + for edge in view_edges: + from_id = _semantic_edge_endpoint(edge, "from") + to_id = _semantic_edge_endpoint(edge, "to") + if from_id is None or to_id is None: + continue + other_id: str | None = None + if from_id in target_ids: + other_id = to_id + elif to_id in target_ids: + other_id = from_id + if ( + other_id is not None + and other_id in selected_ids + and other_id not in seen + and _semantic_endpoint_is_network_route_config_detail(other_id, visible_node_types) + ): + route_config_ids.append(other_id) + seen.add(other_id) + return route_config_ids + + +def _semantic_return_route_config_target_ids( + selected_ids: set[str], + cen_route_config_ids: list[str], + view_edges: list[dict[str, Any]], + visible_node_types: dict[str, str], +) -> list[str]: + route_config_ids: list[str] = [] + seen: set[str] = set() + cen_route_config_set = set(cen_route_config_ids) + for edge in view_edges: + from_id = _semantic_edge_endpoint(edge, "from") + to_id = _semantic_edge_endpoint(edge, "to") + if from_id is None or to_id is None: + continue + other_id: str | None = None + if from_id in cen_route_config_set: + other_id = to_id + elif to_id in cen_route_config_set: + other_id = from_id + if ( + other_id is not None + and other_id in selected_ids + and other_id not in cen_route_config_set + and other_id not in seen + and _semantic_endpoint_is_network_route_config_detail(other_id, visible_node_types) + ): + route_config_ids.append(other_id) + seen.add(other_id) + for route_config_id in cen_route_config_ids: + if route_config_id not in seen: + route_config_ids.append(route_config_id) + seen.add(route_config_id) + return route_config_ids + + +def _first_disconnected_route_chain_target( + forwarder_id: str, + route_config_ids: list[str], + transit_ids: set[str], + view_edges: list[dict[str, Any]], +) -> str | None: + for route_config_id in route_config_ids: + if _find_existing_edge_index(view_edges, forwarder_id, route_config_id) is None: + return route_config_id + for transit_id in sorted(transit_ids): + if not _semantic_view_has_path(forwarder_id, {transit_id}, view_edges): + return transit_id + return None + + +def _semantic_nat_endpoint_id( + from_id: str, + to_id: str, + visible_node_types: dict[str, str], + group_members: dict[str, list[str]], + group_parents: dict[str, str], +) -> str | None: + if _semantic_endpoint_is_nat_gateway(from_id, visible_node_types, group_members, group_parents): + return from_id + if _semantic_endpoint_is_nat_gateway(to_id, visible_node_types, group_members, group_parents): + return to_id + return None + + +def _edge_endpoint_ids(edges: list[dict[str, Any]]) -> set[str]: + endpoint_ids: set[str] = set() + for edge in edges: + from_id = _semantic_edge_endpoint(edge, "from") + to_id = _semantic_edge_endpoint(edge, "to") + if from_id is not None: + endpoint_ids.add(from_id) + if to_id is not None: + endpoint_ids.add(to_id) + return endpoint_ids + + +def _drop_redundant_detail_views(views: list[dict[str, Any]]) -> list[dict[str, Any]]: + overview = next((view for view in views if str(view.get("id") or "") == "overview"), None) + if overview is None: + return views + return [ + view + for view in views + if str(view.get("id") or "") == "overview" + or ( + not _is_redundant_small_group_detail_view(view, overview) + and not _is_redundant_endpoint_repeat_detail_view(view, overview) + ) + ] + + +def _complete_detail_views_from_overview_edges(views: list[dict[str, Any]]) -> list[dict[str, Any]]: + overview = next((view for view in views if str(view.get("id") or "") == "overview"), None) + if overview is None: + return views + overview_edges = _list_of_dicts(overview.get("edges")) + if not overview_edges: + return views + overview_group_members = _semantic_view_group_members(overview) + if not overview_group_members: + overview_group_members = {} + + repaired_views: list[dict[str, Any]] = [] + for view in views: + view_id = str(view.get("id") or "") + if not view_id.startswith("detail_"): + repaired_views.append(view) + continue + selected_ids = _semantic_view_selected_ids(view) + if len(selected_ids) < 2: + repaired_views.append(view) + continue + view_edges = [dict(edge) for edge in _list_of_dicts(view.get("edges"))] + changed = False + for overview_edge in overview_edges: + for from_id, to_id in _project_overview_edge_endpoints_to_detail( + overview_edge, + selected_ids, + overview_group_members, + ): + if _find_existing_edge_index(view_edges, from_id, to_id) is not None: + continue + view_edges.append( + { + "from": from_id, + "to": to_id, + "kind": str(overview_edge.get("kind") or "inferred"), + "label": str(overview_edge.get("label") or ""), + } + ) + changed = True + if len(view_edges) >= 8: + break + if len(view_edges) >= 8: + break + if not changed: + repaired_views.append(view) + continue + repaired_view = dict(view) + repaired_view["edges"] = view_edges + repaired_views.append(repaired_view) + return repaired_views + + +def _project_overview_edge_endpoints_to_detail( + overview_edge: dict[str, Any], + selected_ids: set[str], + overview_group_members: dict[str, list[str]], +) -> list[tuple[str, str]]: + from_id = _semantic_edge_endpoint(overview_edge, "from") + to_id = _semantic_edge_endpoint(overview_edge, "to") + if from_id is None or to_id is None: + return [] + + from_candidates = _project_overview_endpoint_to_detail(from_id, selected_ids, overview_group_members) + to_candidates = _project_overview_endpoint_to_detail(to_id, selected_ids, overview_group_members) + candidates: list[tuple[str, str]] = [] + for candidate_from in from_candidates: + for candidate_to in to_candidates: + if candidate_from == candidate_to: + continue + candidates.append((candidate_from, candidate_to)) + if len(candidates) >= 4: + return candidates + return candidates + + +def _project_overview_endpoint_to_detail( + endpoint_id: str, + selected_ids: set[str], + overview_group_members: dict[str, list[str]], +) -> list[str]: + if endpoint_id in selected_ids: + return [endpoint_id] + member_ids = overview_group_members.get(endpoint_id) + if not member_ids: + return [] + return [member_id for member_id in member_ids if member_id in selected_ids] + + +def _merge_small_detail_views_into_overview( + architecture_context: dict[str, Any], + views: list[dict[str, Any]], +) -> list[dict[str, Any]]: + overview = next((view for view in views if str(view.get("id") or "") == "overview"), None) + if overview is None: + return views + + merged_overview = overview + remaining_views: list[dict[str, Any]] = [] + for view in views: + if view is overview: + continue + if _can_merge_small_detail_view_into_overview(architecture_context, view, merged_overview): + merged_overview = _merge_detail_view_into_overview(merged_overview, view) + else: + remaining_views.append(view) + return [merged_overview, *remaining_views] + + +def _can_merge_small_detail_view_into_overview( + architecture_context: dict[str, Any], + view: dict[str, Any], + overview: dict[str, Any], +) -> bool: + view_id = str(view.get("id") or "") + if view_id != "detail_network": + return False + if not _list_of_dicts(architecture_context.get("network_attachments")): + return False + if not _list_of_dicts(overview.get("edges")): + return False + if _list_of_dicts(view.get("groups")): + return False + + detail_nodes = _dedupe_strings(view.get("nodes")) + detail_edges = _list_of_dicts(view.get("edges")) + if not detail_nodes or not detail_edges: + return False + if len(detail_nodes) > 3 or len(detail_edges) > 2: + return False + + overview_selected_ids = _semantic_view_selected_ids(overview) + anchor_ids = _semantic_view_anchor_ids(view) + if anchor_ids and not anchor_ids.issubset(overview_selected_ids): + return False + + merged = _merge_detail_view_into_overview(overview, view) + if len(_semantic_view_selected_ids(merged)) > 8: + return False + if len(_list_of_dicts(merged.get("edges"))) > 6: + return False + return True + + +def _merge_detail_view_into_overview(overview: dict[str, Any], view: dict[str, Any]) -> dict[str, Any]: + member_group = _overview_member_group_map(overview) + merged_nodes = _dedupe_strings(overview.get("nodes")) + for node_id in _dedupe_strings(view.get("nodes")): + if node_id in member_group: + continue + if node_id not in merged_nodes: + merged_nodes.append(node_id) + + merged_edges = [dict(edge) for edge in _list_of_dicts(overview.get("edges"))] + for edge in _list_of_dicts(view.get("edges")): + from_id = _semantic_edge_endpoint(edge, "from") + to_id = _semantic_edge_endpoint(edge, "to") + if from_id is None or to_id is None: + continue + mapped_from = member_group.get(from_id, from_id) + mapped_to = member_group.get(to_id, to_id) + if mapped_from == mapped_to: + continue + candidate = {**edge, "from": mapped_from, "to": mapped_to} + existing_index = _find_existing_edge_index(merged_edges, mapped_from, mapped_to) + if existing_index is None: + merged_edges.append(candidate) + continue + existing = merged_edges[existing_index] + existing["label"] = _merged_detail_edge_label( + str(existing.get("label") or ""), + str(candidate.get("label") or ""), + ) + return {**overview, "nodes": merged_nodes, "edges": merged_edges} + + +def _overview_member_group_map(overview: dict[str, Any]) -> dict[str, str]: + selected_node_ids = set(_dedupe_strings(overview.get("nodes"))) + member_group: dict[str, str] = {} + for group_id, members in _semantic_view_group_members(overview).items(): + if group_id not in selected_node_ids: + continue + for member_id in members: + member_group.setdefault(member_id, group_id) + return member_group + + +def _find_existing_edge_index(edges: list[dict[str, Any]], from_id: str, to_id: str) -> int | None: + reverse_index: int | None = None + for index, edge in enumerate(edges): + edge_from = _semantic_edge_endpoint(edge, "from") + edge_to = _semantic_edge_endpoint(edge, "to") + if edge_from == from_id and edge_to == to_id: + return index + if edge_from == to_id and edge_to == from_id: + reverse_index = index + return reverse_index + + +def _merged_detail_edge_label(existing_label: str, candidate_label: str) -> str: + candidate_mentions_external = _semantic_text_mentions_external_cen_network(candidate_label) + existing_mentions_external = _semantic_text_mentions_external_cen_network(existing_label) + if candidate_mentions_external and not existing_mentions_external: + return candidate_label + if not existing_label: + return candidate_label + return existing_label + + +def _drop_redundant_attachment_marker_nodes_from_views( + architecture_context: dict[str, Any], + views: list[dict[str, Any]], +) -> list[dict[str, Any]]: + marker_to_summary = _attachment_marker_layer_summary_ids(architecture_context) + if not marker_to_summary: + return views + + repaired_views: list[dict[str, Any]] = [] + for view in views: + selected_ids = set(_dedupe_strings(view.get("nodes"))) + redundant_markers = { + marker_id + for marker_id, summary_id in marker_to_summary.items() + if marker_id in selected_ids and summary_id in selected_ids + } + if not redundant_markers: + repaired_views.append(view) + continue + + repaired_view = dict(view) + repaired_view["nodes"] = [ + node_id for node_id in _dedupe_strings(view.get("nodes")) if node_id not in redundant_markers + ] + if "anchors" in repaired_view: + repaired_view["anchors"] = [ + anchor_id for anchor_id in _dedupe_strings(view.get("anchors")) if anchor_id not in redundant_markers + ] + repaired_groups: list[dict[str, Any]] = [] + for group in _list_of_dicts(view.get("groups")): + group_id = str(group.get("id") or group.get("group_id") or "") + if group_id in redundant_markers: + continue + members = [ + member_id for member_id in _dedupe_strings(group.get("members")) if member_id not in redundant_markers + ] + repaired_group = dict(group) + repaired_group["members"] = members + repaired_groups.append(repaired_group) + if "groups" in repaired_view: + repaired_view["groups"] = repaired_groups + repaired_edges: list[dict[str, Any]] = [] + for edge in _list_of_dicts(view.get("edges")): + from_id = _semantic_edge_endpoint(edge, "from") + to_id = _semantic_edge_endpoint(edge, "to") + if from_id in redundant_markers or to_id in redundant_markers: + continue + repaired_edges.append(edge) + repaired_view["edges"] = repaired_edges + repaired_views.append(repaired_view) + return repaired_views + + +def _attachment_marker_layer_summary_ids(architecture_context: dict[str, Any]) -> dict[str, str]: + summary_ids = { + str(item.get("id")) + for item in _list_of_dicts(architecture_context.get("visible_nodes")) + if item.get("type") == "CONCEPT::Layer::AttachmentSummary" and isinstance(item.get("id"), str) + } + marker_to_summary: dict[str, str] = {} + for attachment in _list_of_dicts(architecture_context.get("attachments")): + marker_id = attachment.get("marker") + target_id = attachment.get("target") + if not isinstance(marker_id, str) or not isinstance(target_id, str): + continue + summary_id = _layer_attachment_summary_node_id(target_id) + if summary_id in summary_ids: + marker_to_summary[marker_id] = summary_id + return marker_to_summary + + +def _layer_attachment_summary_node_id(layer_id: str) -> str: + return re.sub(r"[^A-Za-z0-9_]", "_", f"layer_{layer_id}_Config") + + +def _is_redundant_small_group_detail_view(view: dict[str, Any], overview: dict[str, Any]) -> bool: + view_id = str(view.get("id") or "") + if not view_id.startswith("detail_") or view_id == "detail_network": + return False + if _list_of_dicts(view.get("groups")): + return False + + overview_group_members = _semantic_view_group_members(overview) + anchor_ids = _semantic_view_anchor_ids(view) + expanded_group_ids = sorted(group_id for group_id in anchor_ids if group_id in overview_group_members) + if not expanded_group_ids: + return False + if any(len(overview_group_members[group_id]) > 2 for group_id in expanded_group_ids): + return False + + detail_node_ids = set(_dedupe_strings(view.get("nodes"))) + expanded_members = { + member_id for group_id in expanded_group_ids for member_id in overview_group_members.get(group_id, []) + } + if not expanded_members or not expanded_members.issubset(detail_node_ids): + return False + if len(detail_node_ids) > len(expanded_members) + 2: + return False + + overview_selected_ids = _semantic_view_selected_ids(overview) + non_member_ids = detail_node_ids - expanded_members + if not non_member_ids or not non_member_ids.issubset(overview_selected_ids - set(expanded_group_ids)): + return False + + detail_edges = _list_of_dicts(view.get("edges")) + if not detail_edges: + return False + overview_edge_labels = _overview_edge_labels_by_endpoint(overview) + for edge in detail_edges: + from_id = _semantic_edge_endpoint(edge, "from") + to_id = _semantic_edge_endpoint(edge, "to") + if from_id is None or to_id is None: + return False + replacement = _small_group_detail_replacement_edge( + from_id, + to_id, + expanded_group_ids, + overview_group_members, + non_member_ids, + ) + if replacement is None: + return False + overview_label = overview_edge_labels.get(replacement) + if overview_label is None: + return False + if not _semantic_labels_equivalent_for_small_group_detail(overview_label, str(edge.get("label") or "")): + return False + return True + + +def _is_redundant_endpoint_repeat_detail_view(view: dict[str, Any], overview: dict[str, Any]) -> bool: + view_id = str(view.get("id") or "") + if not view_id.startswith("detail_"): + return False + if _list_of_dicts(view.get("groups")): + return False + + detail_node_ids = set(_dedupe_strings(view.get("nodes"))) + if not detail_node_ids or not detail_node_ids.issubset(_semantic_view_selected_ids(overview)): + return False + + detail_pairs = _directed_edge_endpoint_pairs(_list_of_dicts(view.get("edges"))) + if not detail_pairs: + return False + overview_pairs = _directed_edge_endpoint_pairs(_list_of_dicts(overview.get("edges"))) + return detail_pairs.issubset(overview_pairs) + + +def _directed_edge_endpoint_pairs(edges: list[dict[str, Any]]) -> set[tuple[str, str]]: + pairs: set[tuple[str, str]] = set() + for edge in edges: + from_id = _semantic_edge_endpoint(edge, "from") + to_id = _semantic_edge_endpoint(edge, "to") + if from_id is None or to_id is None: + continue + pairs.add((from_id, to_id)) + return pairs + + +def _overview_edge_labels_by_endpoint(overview: dict[str, Any]) -> dict[tuple[str, str], str]: + labels: dict[tuple[str, str], str] = {} + for edge in _list_of_dicts(overview.get("edges")): + from_id = _semantic_edge_endpoint(edge, "from") + to_id = _semantic_edge_endpoint(edge, "to") + if from_id is None or to_id is None: + continue + labels[(from_id, to_id)] = str(edge.get("label") or "") + return labels + + +def _small_group_detail_replacement_edge( + from_id: str, + to_id: str, + expanded_group_ids: list[str], + overview_group_members: dict[str, list[str]], + non_member_ids: set[str], +) -> tuple[str, str] | None: + for group_id in expanded_group_ids: + members = set(overview_group_members.get(group_id, [])) + if from_id in non_member_ids and to_id in members: + return from_id, group_id + if from_id in members and to_id in non_member_ids: + return group_id, to_id + return None + + +def _normalized_semantic_label(label: str) -> str: + return re.sub(r"\s+", "", label).casefold() + + +def _semantic_labels_equivalent_for_small_group_detail(overview_label: str, detail_label: str) -> bool: + if _normalized_semantic_label(overview_label) == _normalized_semantic_label(detail_label): + return True + return _semantic_label_mentions_business_traffic(overview_label) and _semantic_label_mentions_business_traffic( + detail_label + ) + + +def _repair_semantic_views( + architecture_context: dict[str, Any], + raw_views: list[dict[str, Any]], + valid_real_ids: set[str], + valid_node_ids: set[str], +) -> list[dict[str, Any]]: + overview_views = [view for view in raw_views if _normalize_semantic_view_id(view.get("id")) == "overview"] + other_views = [view for view in raw_views if _normalize_semantic_view_id(view.get("id")) != "overview"] + ordered_views = overview_views + other_views + repaired_views: list[dict[str, Any]] = [] + overview_ids: set[str] = set() + needs_placement_overview = _needs_placement_preserving_overview(architecture_context) + for index, view in enumerate(ordered_views): + view_id = _normalize_semantic_view_id(view.get("id")) + if not view_id: + continue + if view_id != "overview" and not view_id.startswith("detail_"): + continue + repaired_view: dict[str, Any] = {"id": view_id} + for key in ("title", "purpose"): + value = view.get(key) + if isinstance(value, str) and value.strip(): + repaired_view[key] = _single_line_label(value, 48) + layout = view.get("layout") + repaired_view["layout"] = ( + layout.strip().lower() + if isinstance(layout, str) + and layout.strip().lower() + in { + "flat", + "contained", + } + else "flat" + ) + if view_id == "overview" and needs_placement_overview: + repaired_view["layout"] = "contained" + groups = _repair_semantic_groups(_list_of_dicts(view.get("groups")), valid_node_ids, valid_real_ids) + group_ids = {str(group["id"]) for group in groups} + known_ids_for_view = valid_real_ids | group_ids + if groups: + repaired_view["groups"] = groups + anchors = _dedupe_strings(view.get("anchors")) + if view_id.startswith("detail_") and overview_ids: + anchors = [anchor for anchor in anchors if anchor in overview_ids] + else: + anchors = [anchor for anchor in anchors if anchor in valid_real_ids or anchor in overview_ids] + nodes = [ + node_id + for node_id in _dedupe_strings(view.get("nodes") or view.get("node_ids") or view.get("container_ids")) + if node_id in known_ids_for_view + ] + max_nodes = 8 if view_id == "overview" else 12 + nodes = nodes[:max_nodes] + if view_id.startswith("detail_") and not anchors and overview_ids: + anchors = [node_id for node_id in nodes if node_id in overview_ids] + if view_id.startswith("detail_") and anchors: + repaired_view["anchors"] = anchors + selected_ids = set(nodes) + view_edges = _repair_semantic_edges( + _list_of_dicts(view.get("edges")), + known_ids_for_view, + max_edges=8, + require_selected_ids=selected_ids, + ) + if not nodes and not groups: + continue + repaired_view["nodes"] = nodes + repaired_view["edges"] = view_edges + repaired_views.append(repaired_view) + if index == 0 and view_id == "overview": + overview_ids = selected_ids | group_ids + return repaired_views + + +def _normalize_semantic_view_id(raw_view_id: Any) -> str: + if not isinstance(raw_view_id, str) or not raw_view_id.strip(): + return "" + view_id = raw_view_id.strip() + legacy_perspective_ids = { + "traffic": "detail_app", + "network": "detail_network", + "placement": "detail_network", + "attachments": "detail_network", + "operations": "detail_operations", + } + return legacy_perspective_ids.get(view_id, view_id) + + +def _repair_semantic_groups( + raw_groups: list[dict[str, Any]], + valid_node_ids: set[str], + valid_real_ids: set[str], +) -> list[dict[str, Any]]: + groups: list[dict[str, Any]] = [] + seen: set[str] = set() + for group in raw_groups: + group_id = group.get("id") or group.get("group_id") + if not isinstance(group_id, str) or not re.match(r"^[A-Za-z][A-Za-z0-9_]*$", group_id): + continue + if group_id in valid_real_ids or group_id in seen: + continue + members = [member for member in _dedupe_strings(group.get("members")) if member in valid_node_ids] + if not members: + continue + cleaned: dict[str, Any] = {"id": group_id, "members": members} + label = group.get("label") + if isinstance(label, str) and label.strip(): + cleaned["label"] = _single_line_label(label, 32) + parent = group.get("parent") or group.get("container") + if isinstance(parent, str) and parent in valid_real_ids: + cleaned["parent"] = parent + groups.append(cleaned) + seen.add(group_id) + return groups + + +def _repair_semantic_edges( + raw_edges: list[dict[str, Any]], + known_ids: set[str], + *, + max_edges: int, + require_selected_ids: set[str] | None, +) -> list[dict[str, Any]]: + repaired_edges: list[dict[str, Any]] = [] + seen: set[tuple[str, str, str]] = set() + for edge in raw_edges: + from_id = _semantic_edge_endpoint(edge, "from") + to_id = _semantic_edge_endpoint(edge, "to") + if from_id not in known_ids or to_id not in known_ids: + continue + if require_selected_ids is not None and ( + from_id not in require_selected_ids or to_id not in require_selected_ids + ): + continue + label = edge.get("label") + if not isinstance(label, str) or not label.strip(): + continue + kind = edge.get("kind") + kind = ( + kind + if isinstance(kind, str) and kind in {"traffic", "dependency", "management", "inferred"} + else "inferred" + ) + edge_key = (from_id, to_id, kind) + if edge_key in seen: + continue + cleaned: dict[str, Any] = { + "from": from_id, + "to": to_id, + "kind": kind, + "label": _single_line_label(label, 18), + } + confidence = edge.get("confidence") + if isinstance(confidence, str) and confidence in {"high", "medium", "low"}: + cleaned["confidence"] = confidence + repaired_edges.append(cleaned) + seen.add(edge_key) + if len(repaired_edges) >= max_edges: + break + return repaired_edges + + +def _dedupe_strings(value: Any) -> list[str]: + if not isinstance(value, list): + return [] + result: list[str] = [] + seen: set[str] = set() + for item in value: + if not isinstance(item, str): + continue + item = item.strip() + if not item or item in seen: + continue + result.append(item) + seen.add(item) + return result + + +def _single_line_label(value: str, max_chars: int) -> str: + label = re.sub(r"\s+", " ", value.replace("\\n", " ").replace("\n", " ")).strip() + return label[:max_chars].rstrip() + + +def should_retry_semantic_plan_attempt(attempt: int, max_attempts: int, validation_issues: list[str]) -> bool: + if not validation_issues or attempt >= max_attempts: + return False + if attempt < 2: + return True + return any(_is_severe_semantic_plan_issue(issue) for issue in validation_issues) + + +def _is_severe_semantic_plan_issue(issue: str) -> bool: + return any( + marker in issue + for marker in ( + "LLM output was not valid semantic_plan JSON", + "semantic_plan has no edges", + "complex architecture should define overview", + "complex architecture views must start with overview", + "complex architecture views must include overview", + "complex architecture views must include at least one detail_", + "network-heavy architecture should include a detail_network", + "view overview has isolated nodes", + "view detail_network uses contained network containers", + "view detail_network should include CEN attached resources", + "view detail_network should explain external CEN networks", + "route it through CEN/TransitRouter", + "crosses VPCs and should mention CEN or cross-VPC", + "uses CEN/TransitRouter as a business traffic endpoint", + "connects CEN/TransitRouter to a load balancer", + "NAT/SNAT should not be drawn as load balancer ingress", + "makes CEN/TransitRouter the visual source", + "network route/config detail nodes", + "repeats CEN/TransitRouter both as an overview node and as a traffic label", + ) + ) + + +def validation_issue_score(validation_issues: list[str]) -> tuple[int, int]: + severe_count = sum(1 for issue in validation_issues if _is_severe_semantic_plan_issue(issue)) + return severe_count, len(validation_issues) + + +async def create_semantic_plan_with_llm( + architecture_context: dict[str, Any], + *, + model: str, + max_tokens: int, + effort_override: str | None = None, + user_prompt: str | None = None, + messages: list[Message] | None = None, + attempt: int | None = None, + previous_plan: dict[str, Any] | None = None, + validation_issues: list[str] | tuple[str, ...] = (), +) -> tuple[str, dict[str, Any] | None, Any, str | None]: + if messages is None and user_prompt is None: + user_prompt = build_semantic_plan_user_prompt( + architecture_context, + attempt=attempt, + previous_plan=previous_plan, + validation_issues=validation_issues, + ) + if messages is None: + messages = [Message.user(user_prompt or "")] + manager = ProviderManager(model=model, credentials=load_credentials(model=model), effort_override=effort_override) + response = await manager.complete( + messages, + SYSTEM_PROMPT, + max_tokens=max_tokens, + ) + semantic_plan, parse_error = try_extract_semantic_plan_json(response.text) + return response.text, semantic_plan, response.usage, parse_error + + +async def create_semantic_plan_for_architecture_with_llm( + architecture_context: dict[str, Any], + template_content: str, + *, + model: str | None = None, + max_tokens: int = 3000, + max_attempts: int = MAX_SEMANTIC_PLAN_ATTEMPTS, + effort_override: str | None = "none", +) -> dict[str, Any]: + """Create a repaired semantic plan using the same LLM loop as the preview script.""" + llm_architecture_context = build_llm_architecture_context(architecture_context) + selected_model = model or load_saved_model() or DEFAULT_MODEL + max_attempts = max(1, max_attempts) + + validation_issues: list[str] = [] + conversation_messages: list[Message] = [] + best_semantic_plan: dict[str, Any] = {} + best_validation_issues: list[str] | None = None + + for attempt in range(1, max_attempts + 1): + sent_validation_issues = list(validation_issues) + user_prompt = build_semantic_plan_user_prompt( + llm_architecture_context, + attempt=attempt, + previous_plan=None, + validation_issues=sent_validation_issues, + include_fact_bundle=attempt == 1, + include_previous_plan=False, + ) + request_messages = [*conversation_messages, Message.user(user_prompt)] + raw_output, parsed_semantic_plan, _usage, parse_error = await create_semantic_plan_with_llm( + llm_architecture_context, + model=selected_model, + max_tokens=max_tokens, + effort_override=effort_override, + user_prompt=user_prompt, + messages=request_messages, + attempt=attempt, + previous_plan=None, + validation_issues=sent_validation_issues, + ) + conversation_messages = [*request_messages, Message.assistant_text(raw_output)] + + if parsed_semantic_plan is None: + validation_issues = [f"LLM output was not valid semantic_plan JSON: {parse_error}"] + if not should_retry_semantic_plan_attempt(attempt, max_attempts, validation_issues): + break + continue + + semantic_plan = repair_semantic_plan_locally(architecture_context, parsed_semantic_plan) + rendered = render_ros_template_architecture(template_content, semantic_plan=semantic_plan) + validation_issues = validate_semantic_plan_result( + architecture_context, + semantic_plan, + rendered.architecture_context, + ) + if best_validation_issues is None or validation_issue_score(validation_issues) < validation_issue_score( + best_validation_issues + ): + best_semantic_plan = semantic_plan + best_validation_issues = validation_issues + if not should_retry_semantic_plan_attempt(attempt, max_attempts, validation_issues): + break + + return best_semantic_plan + + +def _semantic_plan_relationship_edges( + raw_edges: list[dict[str, Any]], + raw_views: list[dict[str, Any]], +) -> list[dict[str, Any]]: + relationship_edges: list[dict[str, Any]] = [] + seen: set[tuple[str, str, str]] = set() + for edge in raw_edges: + from_id = _semantic_edge_endpoint(edge, "from") + to_id = _semantic_edge_endpoint(edge, "to") + label = str(edge.get("label") or "") + if not from_id or not to_id: + continue + key = (from_id, to_id, label) + if key in seen: + continue + relationship_edges.append(edge) + seen.add(key) + for view in raw_views: + for edge in _list_of_dicts(view.get("edges")): + from_id = _semantic_edge_endpoint(edge, "from") + to_id = _semantic_edge_endpoint(edge, "to") + label = str(edge.get("label") or "") + if not from_id or not to_id: + continue + key = (from_id, to_id, label) + if key in seen: + continue + relationship_edges.append(edge) + seen.add(key) + return relationship_edges + + +def validate_semantic_plan_result( + architecture_context: dict[str, Any], + semantic_plan: dict[str, Any], + rendered_context: dict[str, Any], +) -> list[str]: + issues: list[str] = [] + semantic_context = rendered_context.get("semantic_plan") + semantic_context = semantic_context if isinstance(semantic_context, dict) else {} + + for rejected in _list_of_dicts(semantic_context.get("rejected_node_labels")): + node_id = rejected.get("id") or "" + reason = rejected.get("reason") or "rejected" + issues.append(f"node label for {node_id} was rejected: {reason}") + for rejected in _list_of_dicts(semantic_context.get("rejected_edges")): + from_id = rejected.get("from") or "" + to_id = rejected.get("to") or "" + reason = rejected.get("reason") or "rejected" + if reason in {"covered by deterministic edge", "covered by scaled concept"}: + continue + issues.append(f"edge {from_id}->{to_id} was rejected: {reason}") + + raw_node_labels = _list_of_dicts(semantic_plan.get("node_labels")) + raw_edges = _list_of_dicts(semantic_plan.get("edges")) + raw_views = _list_of_dicts(semantic_plan.get("views")) + relationship_edges = _semantic_plan_relationship_edges(raw_edges, raw_views) + if len(raw_node_labels) > 24: + issues.append(f"semantic_plan has {len(raw_node_labels)} node_labels; keep at most 24") + if len(raw_edges) > 16: + issues.append(f"semantic_plan has {len(raw_edges)} edges; keep at most 16") + if not relationship_edges and _needs_semantic_relationships(architecture_context): + issues.append("semantic_plan has no edges; include 2-6 key traffic, management, or dependency relationships") + issues.extend(_semantic_view_plan_issues(architecture_context, raw_views, relationship_edges)) + issues.extend(_semantic_ram_governance_issues(architecture_context, raw_views, relationship_edges)) + issues.extend(_semantic_ack_application_issues(architecture_context, raw_views, relationship_edges)) + issues.extend(_semantic_shared_orchestration_dependency_issues(architecture_context, raw_views, relationship_edges)) + issues.extend(_semantic_scaling_configuration_source_issues(architecture_context, raw_views, relationship_edges)) + accepted_node_labels_by_id = { + str(accepted.get("id")): str(accepted.get("label") or "") + for accepted in _list_of_dicts(semantic_context.get("accepted_node_labels")) + if isinstance(accepted.get("id"), str) + } + issues.extend( + _semantic_generic_network_route_domain_label_issues( + architecture_context, + raw_views, + accepted_node_labels_by_id, + ) + ) + issues.extend(_semantic_external_cen_network_issues(architecture_context, raw_views, accepted_node_labels_by_id)) + issues.extend(_semantic_route_next_hop_forwarder_issues(architecture_context, raw_views)) + + target_language = architecture_context.get("target_language") + target_code = target_language.get("code") if isinstance(target_language, dict) else None + hint_values = _node_hint_values_by_id(architecture_context) + + for accepted in _list_of_dicts(semantic_context.get("accepted_node_labels")): + node_id = str(accepted.get("id") or "") + label = str(accepted.get("label") or "") + if len(label) > 32: + issues.append(f"node label for {node_id} is too long: {label}") + if target_code == "zh" and _needs_chinese_role_label(label): + issues.append(f"node label for {node_id} must be a Chinese role label, got: {label}") + if _copies_raw_identifier_hint(label, hint_values.get(node_id, ())): + issues.append(f"node label for {node_id} copies raw identifier-like name: {label}") + + for accepted in _list_of_dicts(semantic_context.get("accepted_edges")): + from_id = accepted.get("from") or "" + to_id = accepted.get("to") or "" + label = str(accepted.get("label") or "") + if len(label) > 18: + issues.append(f"edge label for {from_id}->{to_id} is too long: {label}") + if "\n" in label or "\\n" in label: + issues.append(f"edge label for {from_id}->{to_id} must be single-line: {label}") + if target_code == "zh" and label and not _contains_cjk(label): + issues.append(f"edge label for {from_id}->{to_id} must use Chinese: {label}") + if _looks_reversed_scaling_source_edge(architecture_context, str(from_id), str(to_id), label): + issues.append( + "ESS scaling configuration source must be drawn from the ECS/template source to the ESS scaling group, " + f"not {from_id}->{to_id}: {label}" + ) + accepted_edges = _list_of_dicts(semantic_context.get("accepted_edges")) + issues.extend(_repeated_edge_shape_issues(architecture_context, accepted_edges)) + + return issues + + +def _semantic_view_plan_issues( + architecture_context: dict[str, Any], + raw_views: list[dict[str, Any]], + raw_edges: list[dict[str, Any]], +) -> list[str]: + issues: list[str] = [] + needs_drilldown = _needs_overview_with_drilldown_views(architecture_context, raw_edges) + if needs_drilldown and not raw_views: + issues.append("complex architecture should define overview plus drill-down detail views") + return issues + + valid_node_ids = { + str(item.get("id")) + for item in _list_of_dicts(architecture_context.get("visible_nodes")) + if isinstance(item.get("id"), str) + } + valid_container_ids = { + str(item.get("id")) + for item in _list_of_dicts(architecture_context.get("containers")) + if isinstance(item.get("id"), str) + } + valid_ids = valid_node_ids | valid_container_ids + visible_node_types = { + str(item.get("id")): str(item.get("type") or "") + for item in _list_of_dicts(architecture_context.get("visible_nodes")) + if isinstance(item.get("id"), str) + } + containment_parent = _semantic_resource_container_map(architecture_context) + container_parent = _semantic_container_parent_map(architecture_context) + overview_group_ids = _semantic_overview_group_ids(raw_views) + overview_group_parents = _semantic_overview_group_parents(raw_views) + needs_non_network_drilldown = _needs_non_network_overview_with_drilldown_views( + architecture_context, + raw_edges, + ) + needs_network_drilldown = _needs_network_drilldown_view(architecture_context) + needs_placement_overview = _needs_placement_preserving_overview(architecture_context) + small_network_covered_by_overview = _small_network_detail_is_covered_by_overview( + architecture_context, + raw_views, + ) + + seen_view_ids: set[str] = set() + detail_view_count = 0 + overview_selected_ids = _semantic_overview_selected_ids(raw_views) + has_detail_network_view = any(str(view.get("id") or "").strip() == "detail_network" for view in raw_views) + overview_view = _semantic_view_by_id(raw_views, "overview") + overview_group_members = _semantic_view_group_members(overview_view) if overview_view is not None else {} + for index, view in enumerate(raw_views, start=1): + view_id = view.get("id") + if not isinstance(view_id, str) or not view_id.strip(): + view_id = f"view_{index}" + issues.append(f"view {index} is missing id") + view_id = view_id.strip() + if view_id in seen_view_ids: + issues.append(f"view {view_id} is duplicated") + seen_view_ids.add(view_id) + if index == 1 and needs_drilldown and view_id != "overview": + issues.append("complex architecture views must start with overview") + if view_id in {"traffic", "network", "placement", "operations", "attachments"}: + issues.append(f"view {view_id} is a perspective view; use overview plus detail_ drill-down views") + if view_id != "overview" and not view_id.startswith("detail_"): + issues.append(f"view {view_id} should be named detail_ unless it is overview") + if view_id.startswith("detail_"): + detail_view_count += 1 + group_ids = _semantic_view_group_ids(view) + group_members = _semantic_view_group_members(view) + group_parents = _semantic_view_group_parents(view) + known_ids_for_view = valid_ids | group_ids + for group_id in group_ids: + if group_id in valid_ids: + issues.append(f"view {view_id} group {group_id} conflicts with a real resource id") + for group_id, member_ids in group_members.items(): + if not member_ids: + issues.append(f"view {view_id} group {group_id} must include members") + for member_id in member_ids: + if member_id not in valid_node_ids: + issues.append(f"view {view_id} group {group_id} references unknown member {member_id}") + for group_id, parent_id in group_parents.items(): + if parent_id not in valid_container_ids: + issues.append(f"view {view_id} group {group_id} references unknown parent {parent_id}") + anchor_ids = _semantic_view_anchor_ids(view) + for anchor_id in anchor_ids: + if anchor_id not in valid_ids and anchor_id not in overview_selected_ids: + issues.append(f"view {view_id} references unknown anchor {anchor_id}") + if view_id.startswith("detail_"): + if not anchor_ids: + issues.append(f"view {view_id} must include anchors from overview") + for anchor_id in sorted(anchor_ids): + if overview_selected_ids and anchor_id not in overview_selected_ids: + issues.append(f"view {view_id} anchor {anchor_id} is not present in overview") + + selected_ids = _semantic_view_selected_ids(view) + if not selected_ids: + issues.append(f"view {view_id} has no nodes") + max_nodes = 8 if view_id == "overview" else 12 + if len(selected_ids) > max_nodes: + issues.append(f"view {view_id} has {len(selected_ids)} nodes; keep at most {max_nodes}") + for selected_id in selected_ids: + if selected_id not in known_ids_for_view: + issues.append(f"view {view_id} references unknown node {selected_id}") + if view_id == "detail_network": + missing_domain_anchors = sorted( + anchor_id + for anchor_id in anchor_ids + if ( + anchor_id in overview_group_ids + and anchor_id in overview_group_parents + and anchor_id not in selected_ids + and overview_group_parents[anchor_id] not in selected_ids + ) + ) + if missing_domain_anchors: + issues.append( + "view detail_network should include anchored network domains " + f"{', '.join(missing_domain_anchors)} as nodes/groups" + ) + missing_attached_resources = _semantic_missing_detail_network_attached_child_resources( + architecture_context, + selected_ids, + valid_ids, + ) + if missing_attached_resources: + issues.append( + "view detail_network should include CEN attached resources " + f"{', '.join(missing_attached_resources)} from network_attachments as flat VPC/domain nodes" + ) + if _semantic_detail_network_missing_multivswitch_domains( + architecture_context, + selected_ids, + group_parents, + ): + issues.append( + "view detail_network should include VSwitch/network domains for multi-VSwitch architecture" + ) + layout = view.get("layout") + if isinstance(layout, str) and layout.strip() and layout.strip().lower() not in {"flat", "contained"}: + issues.append(f"view {view_id} has invalid layout {layout}; use flat or contained") + if view_id == "detail_network" and isinstance(layout, str) and layout.strip().lower() == "contained": + expanding_containers = _semantic_contained_network_detail_application_containers( + architecture_context, + selected_ids, + visible_node_types, + containment_parent, + container_parent, + ) + if expanding_containers: + issues.append( + "view detail_network uses contained network containers " + f"{', '.join(expanding_containers)} that expand application resources; " + "use flat VPC/domain summary nodes instead" + ) + if view_id == "overview" and needs_network_drilldown: + if not isinstance(layout, str) or layout.strip().lower() != "contained": + issues.append("network-heavy overview should use layout=contained to preserve VPC/resource placement") + repeated_ids_by_type = _semantic_repeated_real_node_types(selected_ids, visible_node_types) + for resource_type, node_ids in repeated_ids_by_type.items(): + issues.append( + f"view overview repeats equivalent {resource_type} nodes {', '.join(node_ids)}; " + "use a groups summary node" + ) + if has_detail_network_view: + route_config_ids = sorted( + selected_id + for selected_id in selected_ids + if _semantic_endpoint_is_network_route_config_detail(selected_id, visible_node_types) + ) + if route_config_ids: + issues.append( + "view overview includes network route/config detail nodes " + f"{', '.join(route_config_ids)}; move route/config domains to detail_network" + ) + if view_id == "overview" and needs_placement_overview: + if not isinstance(layout, str) or layout.strip().lower() != "contained": + issues.append( + "placement-sensitive overview should use layout=contained to preserve VPC/VSwitch placement" + ) + + view_edges = _list_of_dicts(view.get("edges")) + if view_id == "overview" and needs_drilldown and len(selected_ids) > 1 and not view_edges: + issues.append("view overview has no edges; connect the main domains/components or move them to detail") + if len(view_edges) > 8: + issues.append(f"view {view_id} has {len(view_edges)} edges; keep at most 8") + issues.extend( + _semantic_detail_app_ingress_source_issues( + view_id, + view, + overview_view, + overview_group_members, + visible_node_types, + ) + ) + has_transit_router = _semantic_view_has_transit_router(selected_ids, visible_node_types) + for edge in view_edges: + from_id = _semantic_edge_endpoint(edge, "from") + to_id = _semantic_edge_endpoint(edge, "to") + if from_id is None or to_id is None: + issues.append(f"view {view_id} has an edge with missing endpoint") + continue + if from_id not in selected_ids or to_id not in selected_ids: + issues.append(f"view {view_id} edge {from_id}->{to_id} references nodes outside the view") + for endpoint_id in (from_id, to_id): + if endpoint_id not in known_ids_for_view: + issues.append(f"view {view_id} references unknown node {endpoint_id}") + label = str(edge.get("label") or "") + kind = str(edge.get("kind") or "") + connects_cen_and_lb = _semantic_edge_connects_transit_router_and_load_balancer( + from_id, + to_id, + visible_node_types, + group_members, + group_parents, + ) + if connects_cen_and_lb: + if view_id == "detail_network" or _semantic_label_mentions_vpc_connection(label): + issues.append( + f"view {view_id} edge {from_id}->{to_id} connects CEN/TransitRouter to a load balancer; " + "use a VPC/domain/route summary endpoint instead" + ) + elif kind == "traffic" or _semantic_label_mentions_business_traffic(label): + issues.append( + f"view {view_id} edge {from_id}->{to_id} uses CEN/TransitRouter as a business traffic " + "endpoint; draw business traffic to the backend load balancer/group and keep CEN as " + "VPC underlay" + ) + else: + issues.append( + f"view {view_id} edge {from_id}->{to_id} connects CEN/TransitRouter to a load balancer; " + "use a VPC/domain/route summary endpoint instead" + ) + elif ( + view_id == "overview" + and _semantic_endpoint_is_transit_router(from_id, visible_node_types) + and _semantic_label_mentions_vpc_connection(label) + ): + issues.append( + f"view overview edge {from_id}->{to_id} makes CEN/TransitRouter the visual source of VPC " + "connectivity; reverse it to VPC/domain -> CEN or keep CEN only in the traffic label" + ) + elif ( + view_id == "overview" + and has_transit_router + and kind == "traffic" + and _semantic_label_mentions_transit_path(label) + and not _semantic_endpoint_is_transit_router(from_id, visible_node_types) + and not _semantic_endpoint_is_transit_router(to_id, visible_node_types) + ): + issues.append( + f"view overview edge {from_id}->{to_id} repeats CEN/TransitRouter both as an overview node " + "and as a traffic label; keep CEN/TransitRouter in detail_network" + ) + if _semantic_edge_connects_nat_and_load_balancer( + from_id, + to_id, + visible_node_types, + group_members, + group_parents, + ): + issues.append( + f"view {view_id} edge {from_id}->{to_id} connects NAT/SNAT to a load balancer; " + "NAT/SNAT should not be drawn as load balancer ingress" + ) + crosses_network = _semantic_edge_crosses_network_domains( + from_id, + to_id, + visible_node_types, + containment_parent, + container_parent, + group_members, + group_parents, + ) + if ( + crosses_network + and not _semantic_endpoint_is_transit_router(from_id, visible_node_types) + and not (_semantic_endpoint_is_transit_router(to_id, visible_node_types)) + ): + if not _semantic_label_mentions_cross_network(label): + issues.append( + f"view {view_id} edge {from_id}->{to_id} crosses VPCs and should mention CEN or cross-VPC" + ) + if view_id == "overview" and has_transit_router and not _semantic_label_mentions_transit_path(label): + issues.append(f"overview edge {from_id}->{to_id} crosses VPCs; route it through CEN/TransitRouter") + if "\n" in label or "\\n" in label: + issues.append(f"view {view_id} edge {from_id}->{to_id} label must be single-line: {label}") + if len(selected_ids) > 2: + isolated_ids = _semantic_view_isolated_ids( + selected_ids, + view_edges, + visible_node_types, + containment_parent, + container_parent, + group_parents, + ) + if isolated_ids: + issues.append( + f"view {view_id} has isolated nodes {', '.join(isolated_ids)}; connect them or move them to detail" + ) + + if raw_views and needs_drilldown and "overview" not in seen_view_ids: + issues.append("complex architecture views must include overview") + needs_any_detail_view = needs_non_network_drilldown or ( + needs_network_drilldown and not small_network_covered_by_overview + ) + if raw_views and needs_any_detail_view and detail_view_count == 0: + issues.append("complex architecture views must include at least one detail_ drill-down view") + if raw_views and needs_network_drilldown and not small_network_covered_by_overview: + if "detail_network" not in seen_view_ids: + issues.append("network-heavy architecture should include a detail_network drill-down view") + return list(dict.fromkeys(issues)) + + +def _semantic_ram_governance_issues( + architecture_context: dict[str, Any], + raw_views: list[dict[str, Any]], + raw_edges: list[dict[str, Any]], +) -> list[str]: + if not _needs_ram_governance_drilldown_view(architecture_context): + return [] + issues: list[str] = [] + view_ids = { + str(view.get("id") or f"view_{index}").strip() + for index, view in enumerate(raw_views, start=1) + if isinstance(view, dict) + } + if "detail_permissions" not in view_ids: + issues.append( + "RAM-heavy architecture should include detail_permissions to explain " + "users, AccessKeys, groups, roles, policies, and resource scopes" + ) + non_permission_details = view_ids & {"detail_app", "detail_data"} + if non_permission_details and "detail_permissions" not in view_ids: + issues.append( + "RAM-heavy architecture is dominated by application/data-flow views; " + "make identity and permission governance the primary story" + ) + if _ram_governance_edges_are_weaker_than_runtime_flow(architecture_context, raw_edges): + issues.append( + "RAM-heavy architecture should prioritize governance edges such as " + "AccessKey->User, User->Group, Group/Role->permission scope over runtime data-flow edges" + ) + detail_permissions = _semantic_view_by_id(raw_views, "detail_permissions") + if detail_permissions is not None: + selected_ids = _semantic_view_selected_ids(detail_permissions) + if len(_ram_selected_ids(architecture_context, selected_ids)) < 2: + issues.append("view detail_permissions should include at least two RAM identity/governance nodes") + if not _permission_scope_selected_ids(architecture_context, selected_ids): + issues.append("view detail_permissions should include governed resource scope nodes") + return issues + + +def _semantic_ack_application_issues( + architecture_context: dict[str, Any], + raw_views: list[dict[str, Any]], + raw_edges: list[dict[str, Any]], +) -> list[str]: + concept_ids = _ack_application_concept_ids(architecture_context) + if not concept_ids or not _list_of_dicts(architecture_context.get("kubernetes_applications")): + return [] + issues: list[str] = [] + node_types = _visible_node_types_by_id(architecture_context) + cluster_ids = { + str(item.get("id")) + for item in _list_of_dicts(architecture_context.get("visible_nodes")) + if str(item.get("type") or "").startswith("ALIYUN::CS::") + } + all_edges = list(raw_edges) + for view in raw_views: + all_edges.extend(_list_of_dicts(view.get("edges"))) + for edge in all_edges: + from_id = str(edge.get("from") or "") + to_id = str(edge.get("to") or "") + label = str(edge.get("label") or "") + kind = str(edge.get("kind") or "") + if ( + from_id in cluster_ids + and kind in {"traffic", "dependency", "inferred"} + and _semantic_type_is_data_backend(node_types.get(to_id, "")) + and _semantic_label_mentions_runtime_data_flow(label) + ): + issues.append( + "ACK/Kubernetes runtime data edges should start from application workload, " + f"not cluster {from_id}; use a CONCEPT::ACK::ApplicationWorkload node for {to_id}" + ) + break + if len(concept_ids) < 2 or not raw_views: + return issues + selected_ids: set[str] = set() + for view in raw_views: + selected_ids.update(_semantic_view_selected_ids(view)) + for edge in _list_of_dicts(view.get("edges")): + from_id = edge.get("from") + to_id = edge.get("to") + if isinstance(from_id, str): + selected_ids.add(from_id) + if isinstance(to_id, str): + selected_ids.add(to_id) + if len(concept_ids & selected_ids) >= 2: + return issues + issues.append( + "ACK/Kubernetes application views should include CONCEPT::ACK nodes to show " + "Ingress/Service/HPA/workload semantics" + ) + return issues + + +def _semantic_shared_orchestration_dependency_issues( + architecture_context: dict[str, Any], + raw_views: list[dict[str, Any]], + raw_edges: list[dict[str, Any]], +) -> list[str]: + issues: list[str] = [] + for action in _list_of_dicts(architecture_context.get("orchestration_actions")): + action_id = str(action.get("id") or "orchestration action") + target_ids = [ + str(target.get("id")) + for target in _list_of_dicts(action.get("targets")) + if target.get("visible") is True and isinstance(target.get("id"), str) + ] + target_ids = list(dict.fromkeys(target_ids)) + if len(target_ids) < 2: + continue + target_set = set(target_ids) + referenced_ids = [ + str(reference.get("id")) + for reference in _list_of_dicts(action.get("referenced_resources")) + if reference.get("visible") is True and isinstance(reference.get("id"), str) + ] + referenced_ids = list(dict.fromkeys(referenced_ids)) + for referenced_id in referenced_ids: + if raw_views: + for index, view in enumerate(raw_views, start=1): + view_id = str(view.get("id") or f"view_{index}").strip() + view_group_members = { + group_id: set(members) for group_id, members in _semantic_view_group_members(view).items() + } + selected_ids = _semantic_view_selected_ids(view) + selected_targets = target_set & selected_ids + for group_id, members in view_group_members.items(): + if group_id in selected_ids: + selected_targets.update(target_set & members) + if len(selected_targets) < 2 or referenced_id not in selected_ids: + continue + covered_targets, fully_grouped = _semantic_shared_dependency_coverage( + _list_of_dicts(view.get("edges")), + view_group_members, + selected_targets, + referenced_id, + ) + if fully_grouped or not covered_targets or covered_targets == selected_targets: + continue + issues.append( + f"view {view_id} partially shows {action_id} dependency {referenced_id}; " + f"it only connects {', '.join(sorted(covered_targets))}. " + "Use a summary group or mirror the shared dependency for every selected target." + ) + else: + covered_targets, fully_grouped = _semantic_shared_dependency_coverage( + raw_edges, + {}, + target_set, + referenced_id, + ) + if fully_grouped or not covered_targets or covered_targets == target_set: + continue + issues.append( + f"{action_id} shares {referenced_id} dependency across {', '.join(target_ids)}; " + f"plan only connects {', '.join(sorted(covered_targets))}. " + "Use a summary group or mirror the shared dependency for every target." + ) + return issues + + +def _semantic_shared_dependency_coverage( + edges: list[dict[str, Any]], + group_members: dict[str, set[str]], + target_set: set[str], + referenced_id: str, +) -> tuple[set[str], bool]: + covered_targets: set[str] = set() + fully_grouped = False + for edge in edges: + from_id = _semantic_edge_endpoint(edge, "from") + to_id = _semantic_edge_endpoint(edge, "to") + if to_id != referenced_id: + continue + if from_id in target_set: + covered_targets.add(from_id) + continue + if from_id in group_members and target_set.issubset(group_members[from_id]): + fully_grouped = True + return covered_targets, fully_grouped + + +def _ram_governance_edges_are_weaker_than_runtime_flow( + architecture_context: dict[str, Any], + raw_edges: list[dict[str, Any]], +) -> bool: + if not raw_edges: + return True + node_types = _visible_node_types_by_id(architecture_context) + governance_count = 0 + runtime_count = 0 + for edge in raw_edges: + from_id = str(edge.get("from") or "") + to_id = str(edge.get("to") or "") + label = str(edge.get("label") or "") + kind = str(edge.get("kind") or "") + from_is_ram = _semantic_type_is_ram_governance(node_types.get(from_id, "")) + to_is_ram = _semantic_type_is_ram_governance(node_types.get(to_id, "")) + if ( + (from_is_ram and to_is_ram) + or _semantic_label_mentions_permission_governance(label) + or (from_is_ram or to_is_ram) + and kind == "management" + ): + governance_count += 1 + if ( + kind in {"traffic", "inferred"} + and not from_is_ram + and not to_is_ram + or _semantic_label_mentions_runtime_data_flow(label) + ): + runtime_count += 1 + return runtime_count >= 2 and governance_count < 2 + + +def _ram_selected_ids(architecture_context: dict[str, Any], selected_ids: set[str]) -> set[str]: + node_types = _visible_node_types_by_id(architecture_context) + return {node_id for node_id in selected_ids if _semantic_type_is_ram_governance(node_types.get(node_id, ""))} + + +def _permission_scope_selected_ids(architecture_context: dict[str, Any], selected_ids: set[str]) -> set[str]: + node_types = _visible_node_types_by_id(architecture_context) + return {node_id for node_id in selected_ids if _semantic_type_is_permission_scope(node_types.get(node_id, ""))} + + +def _semantic_label_mentions_permission_governance(label: str) -> bool: + normalized = re.sub(r"\s+", "", label.casefold()) + return any( + marker in normalized + for marker in ( + "accesskey", + "policy", + "permission", + "role", + "user", + "凭证", + "加入", + "角色", + "权限", + "授权", + "授予", + "用户", + "用户组", + "策略", + "资源范围", + ) + ) + + +def _semantic_label_mentions_runtime_data_flow(label: str) -> bool: + normalized = re.sub(r"\s+", "", label.casefold()) + return any( + marker in normalized + for marker in ( + "database", + "data", + "objectstorage", + "storage", + "traffic", + "上传", + "下载", + "存储", + "数据", + "数据库", + "流量", + "访问", + ) + ) + + +def _semantic_type_is_data_backend(resource_type: str) -> bool: + return ( + any( + marker in resource_type + for marker in ( + "::RDS::", + "::REDIS::", + "::GPDB::", + "::POLARDB::", + "::MongoDB::", + "::DRDS::", + "::ADB::", + "::OSS::", + "::NAS::", + "::Kafka::", + "::RocketMQ::", + "::MNS::", + "::SLS::", + "::DBInstance", + "::FileSystem", + "::Bucket", + ) + ) + and "ALIYUN::CS::" not in resource_type + ) + + +def _semantic_view_selected_ids(view: dict[str, Any]) -> set[str]: + selected_ids: set[str] = set() + for key in ("nodes", "node_ids", "containers", "container_ids"): + value = view.get(key) + if isinstance(value, list): + selected_ids.update(item.strip() for item in value if isinstance(item, str) and item.strip()) + selected_ids.update(_semantic_view_group_ids(view)) + return selected_ids + + +def _semantic_view_anchor_ids(view: dict[str, Any]) -> set[str]: + anchor_ids: set[str] = set() + for key in ("anchors", "anchor_ids"): + value = view.get(key) + if isinstance(value, list): + anchor_ids.update(item.strip() for item in value if isinstance(item, str) and item.strip()) + return anchor_ids + + +def _semantic_view_group_ids(view: dict[str, Any]) -> set[str]: + return set(_semantic_view_group_members(view)) + + +def _semantic_view_group_members(view: dict[str, Any]) -> dict[str, list[str]]: + group_members: dict[str, list[str]] = {} + for raw_group in _list_of_dicts(view.get("groups")): + group_id = raw_group.get("id") + if not isinstance(group_id, str) or not group_id.strip(): + group_id = raw_group.get("group_id") + if not isinstance(group_id, str) or not group_id.strip(): + continue + group_id = group_id.strip() + if not re.match(r"^[A-Za-z][A-Za-z0-9_]*$", group_id): + continue + members = raw_group.get("members") + if not isinstance(members, list): + members = raw_group.get("member_ids") + if not isinstance(members, list): + group_members[group_id] = [] + continue + valid_members = [member_id.strip() for member_id in members if isinstance(member_id, str) and member_id.strip()] + group_members[group_id] = list(dict.fromkeys(valid_members)) + return group_members + + +def _semantic_view_group_parents(view: dict[str, Any]) -> dict[str, str]: + group_parents: dict[str, str] = {} + for raw_group in _list_of_dicts(view.get("groups")): + group_id = raw_group.get("id") + if not isinstance(group_id, str) or not group_id.strip(): + group_id = raw_group.get("group_id") + if not isinstance(group_id, str) or not group_id.strip(): + continue + parent_id = raw_group.get("parent") or raw_group.get("container") + if isinstance(parent_id, str) and parent_id.strip(): + group_parents[group_id.strip()] = parent_id.strip() + return group_parents + + +def _semantic_overview_group_ids(raw_views: list[dict[str, Any]]) -> set[str]: + for index, view in enumerate(raw_views, start=1): + view_id = view.get("id") + if not isinstance(view_id, str) or not view_id.strip(): + view_id = f"view_{index}" + if view_id.strip() == "overview": + return _semantic_view_group_ids(view) + return set() + + +def _semantic_overview_group_parents(raw_views: list[dict[str, Any]]) -> dict[str, str]: + for index, view in enumerate(raw_views, start=1): + view_id = view.get("id") + if not isinstance(view_id, str) or not view_id.strip(): + view_id = f"view_{index}" + if view_id.strip() == "overview": + return _semantic_view_group_parents(view) + return {} + + +def _semantic_resource_container_map(architecture_context: dict[str, Any]) -> dict[str, str]: + parents: dict[str, str] = {} + for item in _list_of_dicts(architecture_context.get("containment")): + resource_id = item.get("resource") + container_id = item.get("container") + if ( + isinstance(resource_id, str) + and resource_id.strip() + and isinstance(container_id, str) + and container_id.strip() + ): + parents[resource_id.strip()] = container_id.strip() + return parents + + +def _semantic_container_parent_map(architecture_context: dict[str, Any]) -> dict[str, str]: + parents: dict[str, str] = {} + for item in _list_of_dicts(architecture_context.get("containers")): + container_id = item.get("id") + parent_id = item.get("parent") + if isinstance(container_id, str) and container_id.strip() and isinstance(parent_id, str) and parent_id.strip(): + parents[container_id.strip()] = parent_id.strip() + return parents + + +def _semantic_missing_detail_network_attached_child_resources( + architecture_context: dict[str, Any], + selected_ids: set[str], + valid_ids: set[str], +) -> list[str]: + missing: list[str] = [] + for attachment in _list_of_dicts(architecture_context.get("network_attachments")): + if attachment.get("type") != "ALIYUN::CEN::CenInstanceAttachment": + continue + child_resource = attachment.get("child_resource") + if not isinstance(child_resource, str) or not child_resource.strip(): + continue + child_resource = child_resource.strip() + if child_resource in valid_ids and child_resource not in selected_ids: + missing.append(child_resource) + return sorted(set(missing)) + + +def _semantic_detail_network_missing_multivswitch_domains( + architecture_context: dict[str, Any], + selected_ids: set[str], + group_parents: dict[str, str], +) -> bool: + visible_node_types = { + str(item.get("id")): str(item.get("type") or "") + for item in _list_of_dicts(architecture_context.get("visible_nodes")) + if isinstance(item.get("id"), str) + } + container_types = { + str(item.get("id")): str(item.get("type") or "") + for item in _list_of_dicts(architecture_context.get("containers")) + if isinstance(item.get("id"), str) + } + vswitch_ids = { + container_id + for container_id, resource_type in container_types.items() + if resource_type == "ALIYUN::ECS::VSwitch" + } + if len(vswitch_ids) < 3: + return False + + def is_network_domain(node_id: str) -> bool: + resource_type = container_types.get(node_id) + if resource_type in {"ALIYUN::ECS::VPC", "ALIYUN::ECS::VSwitch"}: + return True + if _semantic_endpoint_is_network_route_config_detail(node_id, visible_node_types): + return True + parent_id = group_parents.get(node_id) + if parent_id is None: + return False + return container_types.get(parent_id) in {"ALIYUN::ECS::VPC", "ALIYUN::ECS::VSwitch"} + + return not any(is_network_domain(selected_id) for selected_id in selected_ids) + + +def _semantic_detail_app_ingress_source_issues( + view_id: str, + view: dict[str, Any], + overview_view: dict[str, Any] | None, + overview_group_members: dict[str, list[str]], + visible_node_types: dict[str, str], +) -> list[str]: + if view_id != "detail_app" or overview_view is None: + return [] + selected_ids = _semantic_view_selected_ids(view) + anchor_ids = _semantic_view_anchor_ids(view) + detail_group_members = _semantic_view_group_members(view) + issues: list[str] = [] + for overview_edge in _list_of_dicts(overview_view.get("edges")): + edge_kind = str(overview_edge.get("kind") or "") + edge_label = str(overview_edge.get("label") or "") + if edge_kind != "traffic" and not _semantic_label_mentions_business_traffic(edge_label): + continue + from_id = _semantic_edge_endpoint(overview_edge, "from") + to_id = _semantic_edge_endpoint(overview_edge, "to") + if from_id is None or to_id is None: + continue + if not _semantic_endpoint_is_or_contains_load_balancer( + from_id, + visible_node_types, + overview_group_members, + ): + continue + if not _semantic_endpoint_is_present_or_expanded_in_detail_app( + to_id, + selected_ids, + anchor_ids, + detail_group_members, + overview_group_members, + ): + continue + if _semantic_endpoint_is_present_or_expanded_in_detail_app( + from_id, + selected_ids, + anchor_ids, + detail_group_members, + overview_group_members, + ): + continue + issues.append(f"view detail_app should include overview traffic source {from_id} when expanding {to_id}") + return issues + + +def _semantic_endpoint_is_present_or_expanded_in_detail_app( + endpoint_id: str, + selected_ids: set[str], + anchor_ids: set[str], + detail_group_members: dict[str, list[str]], + overview_group_members: dict[str, list[str]], +) -> bool: + if endpoint_id in selected_ids or endpoint_id in anchor_ids: + return True + for member_id in overview_group_members.get(endpoint_id, []): + if member_id in selected_ids or member_id in anchor_ids: + return True + for member_id in detail_group_members.get(endpoint_id, []): + if member_id in selected_ids or member_id in anchor_ids: + return True + return False + + +def _semantic_endpoint_is_or_contains_load_balancer( + endpoint_id: str, + visible_node_types: dict[str, str], + group_members: dict[str, list[str]], +) -> bool: + if _semantic_type_is_load_balancer(visible_node_types.get(endpoint_id, "")): + return True + return any( + _semantic_endpoint_is_or_contains_load_balancer(member_id, visible_node_types, group_members) + for member_id in group_members.get(endpoint_id, []) + ) + + +def _semantic_generic_network_route_domain_label_issues( + architecture_context: dict[str, Any], + raw_views: list[dict[str, Any]], + accepted_node_labels_by_id: dict[str, str], +) -> list[str]: + detail_network = _semantic_view_by_id(raw_views, "detail_network") + if detail_network is None: + return [] + selected_ids = _semantic_view_selected_ids(detail_network) + visible_node_types = { + str(item.get("id")): str(item.get("type") or "") + for item in _list_of_dicts(architecture_context.get("visible_nodes")) + if isinstance(item.get("id"), str) + } + visible_labels = { + str(item.get("id")): str(item.get("label") or "") + for item in _list_of_dicts(architecture_context.get("visible_nodes")) + if isinstance(item.get("id"), str) + } + generic_ids: list[str] = [] + for selected_id in sorted(selected_ids): + if not _semantic_endpoint_is_network_route_config_detail(selected_id, visible_node_types): + continue + label = accepted_node_labels_by_id.get(selected_id) or visible_labels.get(selected_id, "") + if _semantic_route_config_label_is_generic(label): + generic_ids.append(selected_id) + if not generic_ids: + return [] + return [ + "view detail_network route/config domain labels should describe purpose, not generic VPC config: " + + ", ".join(generic_ids) + ] + + +def _semantic_route_config_label_is_generic(label: str) -> bool: + normalized = re.sub(r"\s+", "", label.casefold()) + if not normalized: + return False + generic_labels = { + "vpc配置", + "vpc路由配置", + "vpcrouteconfig", + "vpcrouting", + "routeconfig", + "routingconfig", + "专有网络vpc配置", + "专有网络配置", + "专有网络路由配置", + "路由配置", + "网络配置", + } + if normalized in generic_labels: + return True + purpose_tokens = ( + "dmz", + "prod", + "production", + "生产", + "测试", + "开发", + "出口", + "入口", + "nat", + "snat", + "cen", + "互联", + "跨", + "外部", + "对端", + "公网", + "私网", + "安全", + "前端", + "后端", + "接入", + "管理", + "网关", + "frontend", + "backend", + "front", + "back", + "access", + "management", + "gateway", + "入向", + "出向", + "转发", + ) + generic_tokens = ("vpc", "专有网络", "路由", "route", "配置", "config") + return any(token in normalized for token in generic_tokens) and not any( + token in normalized for token in purpose_tokens + ) + + +def _semantic_external_cen_network_issues( + architecture_context: dict[str, Any], + raw_views: list[dict[str, Any]], + accepted_node_labels_by_id: dict[str, str], +) -> list[str]: + external_attachments = _semantic_external_cen_network_attachments(architecture_context) + if not external_attachments: + return [] + detail_network = _semantic_view_by_id(raw_views, "detail_network") + if detail_network is None: + return [] + selected_ids = _semantic_view_selected_ids(detail_network) + cen_config_ids = _semantic_selected_cen_config_ids(architecture_context, selected_ids) + if not cen_config_ids: + return [] + text_parts: list[str] = [] + visible_labels = { + str(item.get("id")): str(item.get("label") or "") + for item in _list_of_dicts(architecture_context.get("visible_nodes")) + if isinstance(item.get("id"), str) + } + for node_id in sorted(cen_config_ids): + text_parts.append(accepted_node_labels_by_id.get(node_id, "")) + text_parts.append(visible_labels.get(node_id, "")) + for edge in _list_of_dicts(detail_network.get("edges")): + text_parts.append(str(edge.get("label") or "")) + if any(_semantic_text_mentions_external_cen_network(text) for text in text_parts): + return [] + type_counts: dict[str, int] = {} + for attachment in external_attachments: + child_type = str(attachment.get("child_instance_type") or "network").upper() + type_counts[child_type] = type_counts.get(child_type, 0) + 1 + type_summary = "/".join( + f"{child_type} x{count}" if count > 1 else child_type for child_type, count in sorted(type_counts.items()) + ) + return [ + "view detail_network should explain external CEN networks " + f"({type_summary}) instead of only drawing the local VPC to CEN" + ] + + +def _semantic_route_next_hop_forwarder_issues( + architecture_context: dict[str, Any], + raw_views: list[dict[str, Any]], +) -> list[str]: + if not _list_of_dicts(architecture_context.get("network_attachments")): + return [] + forwarder_ids = _semantic_route_next_hop_compute_ids(architecture_context) + if not forwarder_ids: + return [] + detail_network = _semantic_view_by_id(raw_views, "detail_network") + if detail_network is None: + return [] + selected_ids = _semantic_view_selected_ids(detail_network) + selected_forwarders = sorted(forwarder_ids & selected_ids) + if not selected_forwarders: + return [] + visible_node_types = { + str(item.get("id")): str(item.get("type") or "") + for item in _list_of_dicts(architecture_context.get("visible_nodes")) + if isinstance(item.get("id"), str) + } + transit_ids = { + selected_id + for selected_id in selected_ids + if _semantic_endpoint_is_transit_router(selected_id, visible_node_types) + } + if not transit_ids: + return [] + view_edges = _list_of_dicts(detail_network.get("edges")) + connected_forwarders = { + forwarder_id + for forwarder_id in selected_forwarders + if _semantic_view_has_path(forwarder_id, transit_ids, view_edges) + } + missing = sorted(set(selected_forwarders) - connected_forwarders) + if not missing: + return [] + return [ + "view detail_network should connect route next-hop compute " + f"{', '.join(missing)} into the CEN/TransitRouter routing path" + ] + + +def _semantic_route_next_hop_compute_ids(architecture_context: dict[str, Any]) -> set[str]: + compute_ids: set[str] = set() + for relation in _list_of_dicts(architecture_context.get("explicit_relations")): + if relation.get("source_type") != "ALIYUN::ECS::Route" or relation.get("property") != "NextHopId": + continue + target_id = relation.get("target") + target_type = str(relation.get("target_type") or "") + if isinstance(target_id, str) and _semantic_type_is_route_next_hop_compute(target_type): + compute_ids.add(target_id) + return compute_ids + + +def _semantic_type_is_route_next_hop_compute(resource_type: str) -> bool: + normalized = resource_type.casefold() + return "::ecs::instance" in normalized or "::ecs::instancegroup" in normalized + + +def _semantic_view_has_path( + source_id: str, + target_ids: set[str], + view_edges: list[dict[str, Any]], +) -> bool: + adjacency: dict[str, set[str]] = {} + for edge in view_edges: + from_id = _semantic_edge_endpoint(edge, "from") + to_id = _semantic_edge_endpoint(edge, "to") + if from_id is None or to_id is None: + continue + adjacency.setdefault(from_id, set()).add(to_id) + adjacency.setdefault(to_id, set()).add(from_id) + seen: set[str] = set() + queue = [source_id] + while queue: + current = queue.pop(0) + if current in target_ids: + return True + if current in seen: + continue + seen.add(current) + queue.extend(sorted(adjacency.get(current, set()) - seen)) + return False + + +def _semantic_external_cen_network_attachments(architecture_context: dict[str, Any]) -> list[dict[str, Any]]: + external: list[dict[str, Any]] = [] + for attachment in _list_of_dicts(architecture_context.get("network_attachments")): + if attachment.get("type") != "ALIYUN::CEN::CenInstanceAttachment": + continue + child_type = str(attachment.get("child_instance_type") or "").upper() + if child_type not in {"VPC", "VBR"}: + continue + child_resource = attachment.get("child_resource") + if isinstance(child_resource, str) and child_resource.strip(): + continue + child_id = str(attachment.get("child_instance_id") or "") + if child_id.startswith("Ref:") or child_id: + external.append(attachment) + return external + + +def _semantic_view_by_id(raw_views: list[dict[str, Any]], view_id: str) -> dict[str, Any] | None: + for index, view in enumerate(raw_views, start=1): + if _semantic_view_id_for_validation(view, index) == view_id: + return view + return None + + +def _semantic_view_id_for_validation(view: dict[str, Any], index: int) -> str: + value = view.get("id") + if not isinstance(value, str) or not value.strip(): + return f"view_{index}" + return value.strip() + + +def _semantic_selected_cen_config_ids( + architecture_context: dict[str, Any], + selected_ids: set[str], +) -> set[str]: + result: set[str] = set() + for item in _list_of_dicts(architecture_context.get("visible_nodes")): + node_id = item.get("id") + if not isinstance(node_id, str) or node_id not in selected_ids: + continue + resource_type = str(item.get("type") or "") + label = str(item.get("label") or "") + if resource_type.startswith("CONCEPT::") and ("CEN" in label.upper() or "CEN" in node_id.upper()): + result.add(node_id) + elif "::CEN::" in resource_type: + result.add(node_id) + return result + + +def _semantic_text_mentions_external_cen_network(text: str) -> bool: + normalized = text.casefold() + return any( + token in normalized + for token in ( + "外部", + "已有", + "现有", + "对端", + "外部网络", + "外部 vpc", + "外部vpc", + "外部 vbr", + "外部vbr", + "vpc/vbr", + "vbr", + "other vpc", + "other vbr", + "external", + "peer", + ) + ) + + +def _semantic_contained_network_detail_application_containers( + architecture_context: dict[str, Any], + selected_ids: set[str], + visible_node_types: dict[str, str], + containment_parent: dict[str, str], + container_parent: dict[str, str], +) -> list[str]: + if not _semantic_selected_ids_have_network_interconnect_detail( + architecture_context, selected_ids, visible_node_types + ): + return [] + selected_container_ids = { + selected_id for selected_id in selected_ids if selected_id not in visible_node_types and selected_id + } + expanding_containers: list[str] = [] + for container_id in sorted(selected_container_ids): + for node_id, parent_id in containment_parent.items(): + if not _semantic_container_is_descendant_or_same(parent_id, container_id, container_parent): + continue + if _semantic_type_is_application_resource(visible_node_types.get(node_id, "")): + expanding_containers.append(container_id) + break + return expanding_containers + + +def _semantic_selected_ids_have_network_interconnect_detail( + architecture_context: dict[str, Any], + selected_ids: set[str], + visible_node_types: dict[str, str], +) -> bool: + if _list_of_dicts(architecture_context.get("network_attachments")): + return True + return any( + _semantic_endpoint_is_transit_router(selected_id, visible_node_types) + or _semantic_endpoint_is_network_route_config_detail(selected_id, visible_node_types) + or _semantic_type_is_nat_gateway(visible_node_types.get(selected_id, "")) + for selected_id in selected_ids + ) + + +def _semantic_container_is_descendant_or_same( + container_id: str, + ancestor_id: str, + container_parent: dict[str, str], +) -> bool: + current = container_id + seen: set[str] = set() + while current and current not in seen: + if current == ancestor_id: + return True + seen.add(current) + current = container_parent.get(current, "") + return False + + +def _semantic_type_is_application_resource(resource_type: str) -> bool: + normalized = resource_type.casefold() + if not normalized or normalized.startswith("concept::"): + return False + return any( + marker in normalized + for marker in ( + "::ecs::instance", + "::ecs::instancegroup", + "::ess::scalinggroup", + "::alb::", + "::nlb::", + "::slb::", + "loadbalancer", + "::rds::", + "::polardb::", + "::redis::", + "::nas::filesystem", + "::oss::bucket", + "::ots::", + "::mongodb::", + ) + ) + + +def _semantic_edge_crosses_network_domains( + from_id: str, + to_id: str, + visible_node_types: dict[str, str], + containment_parent: dict[str, str], + container_parent: dict[str, str], + group_members: dict[str, list[str]], + group_parents: dict[str, str], +) -> bool: + from_roots = _semantic_endpoint_root_containers( + from_id, visible_node_types, containment_parent, container_parent, group_members, group_parents + ) + to_roots = _semantic_endpoint_root_containers( + to_id, visible_node_types, containment_parent, container_parent, group_members, group_parents + ) + return bool(from_roots and to_roots and from_roots.isdisjoint(to_roots)) + + +def _semantic_endpoint_root_containers( + endpoint_id: str, + visible_node_types: dict[str, str], + containment_parent: dict[str, str], + container_parent: dict[str, str], + group_members: dict[str, list[str]], + group_parents: dict[str, str], +) -> set[str]: + if endpoint_id in group_parents: + return {_semantic_root_container(group_parents[endpoint_id], container_parent)} + if endpoint_id in group_members: + roots: set[str] = set() + for member_id in group_members[endpoint_id]: + roots.update( + _semantic_endpoint_root_containers( + member_id, + visible_node_types, + containment_parent, + container_parent, + group_members, + group_parents, + ) + ) + return roots + if endpoint_id in containment_parent: + return {_semantic_root_container(containment_parent[endpoint_id], container_parent)} + if endpoint_id not in visible_node_types and endpoint_id: + return {_semantic_root_container(endpoint_id, container_parent)} + return set() + + +def _semantic_root_container(container_id: str, container_parent: dict[str, str]) -> str: + current = container_id + seen: set[str] = set() + while current in container_parent and current not in seen: + seen.add(current) + current = container_parent[current] + return current + + +def _semantic_view_has_transit_router(selected_ids: set[str], visible_node_types: dict[str, str]) -> bool: + return any(_semantic_endpoint_is_transit_router(selected_id, visible_node_types) for selected_id in selected_ids) + + +def _semantic_endpoint_is_transit_router(endpoint_id: str, visible_node_types: dict[str, str]) -> bool: + resource_type = visible_node_types.get(endpoint_id, "") + return "::CEN::" in resource_type or "TransitRouter" in resource_type + + +def _semantic_endpoint_is_network_route_config_detail(endpoint_id: str, visible_node_types: dict[str, str]) -> bool: + resource_type = visible_node_types.get(endpoint_id, "") + normalized = resource_type.casefold() + return ( + resource_type == "CONCEPT::Layer::AttachmentSummary" + or normalized.endswith("::route") + or "routetable" in normalized + or "routeentry" in normalized + or "routerinterface" in normalized + ) + + +def _semantic_edge_connects_transit_router_and_load_balancer( + from_id: str, + to_id: str, + visible_node_types: dict[str, str], + group_members: dict[str, list[str]], + group_parents: dict[str, str], +) -> bool: + return ( + _semantic_endpoint_is_transit_router(from_id, visible_node_types) + and _semantic_endpoint_is_load_balancer(to_id, visible_node_types, group_members, group_parents) + ) or ( + _semantic_endpoint_is_transit_router(to_id, visible_node_types) + and _semantic_endpoint_is_load_balancer(from_id, visible_node_types, group_members, group_parents) + ) + + +def _semantic_edge_connects_nat_and_load_balancer( + from_id: str, + to_id: str, + visible_node_types: dict[str, str], + group_members: dict[str, list[str]], + group_parents: dict[str, str], +) -> bool: + return ( + _semantic_endpoint_is_nat_gateway(from_id, visible_node_types, group_members, group_parents) + and _semantic_endpoint_is_load_balancer(to_id, visible_node_types, group_members, group_parents) + ) or ( + _semantic_endpoint_is_nat_gateway(to_id, visible_node_types, group_members, group_parents) + and _semantic_endpoint_is_load_balancer(from_id, visible_node_types, group_members, group_parents) + ) + + +def _semantic_endpoint_is_load_balancer( + endpoint_id: str, + visible_node_types: dict[str, str], + group_members: dict[str, list[str]], + group_parents: dict[str, str], +) -> bool: + if endpoint_id in group_parents: + return False + resource_type = visible_node_types.get(endpoint_id, "") + if _semantic_type_is_load_balancer(resource_type): + return True + member_ids = group_members.get(endpoint_id) + if not member_ids: + return False + return any(_semantic_type_is_load_balancer(visible_node_types.get(member_id, "")) for member_id in member_ids) + + +def _semantic_type_is_load_balancer(resource_type: str) -> bool: + return "LoadBalancer" in resource_type or any( + marker in resource_type for marker in ("::ALB::", "::NLB::", "::SLB::") + ) + + +def _semantic_endpoint_is_nat_gateway( + endpoint_id: str, + visible_node_types: dict[str, str], + group_members: dict[str, list[str]], + group_parents: dict[str, str], +) -> bool: + if endpoint_id in group_parents: + return False + resource_type = visible_node_types.get(endpoint_id, "") + if _semantic_type_is_nat_gateway(resource_type): + return True + member_ids = group_members.get(endpoint_id) + if not member_ids: + return False + return any(_semantic_type_is_nat_gateway(visible_node_types.get(member_id, "")) for member_id in member_ids) + + +def _semantic_type_is_nat_gateway(resource_type: str) -> bool: + normalized = resource_type.casefold() + return "natgateway" in normalized or "::nat::" in normalized + + +def _semantic_label_mentions_cross_network(label: str) -> bool: + normalized = label.lower() + return any( + token in normalized + for token in ("cen", "transit", "cross", "external", "vbr", "跨", "经", "互联", "外部", "转发路由") + ) + + +def _semantic_label_mentions_transit_path(label: str) -> bool: + normalized = label.lower() + return any(token in normalized for token in ("cen", "transit", "经", "转发路由")) + + +def _semantic_label_mentions_business_traffic(label: str) -> bool: + normalized = label.lower() + return any(token in normalized for token in ("traffic", "ingress", "backend", "入口", "流量", "后端", "转发")) + + +def _semantic_label_mentions_vpc_connection(label: str) -> bool: + normalized = label.lower() + return any(token in normalized for token in ("vpc", "连接", "接入", "互联", "路由")) + + +def _semantic_repeated_real_node_types( + selected_ids: set[str], visible_node_types: dict[str, str] +) -> dict[str, list[str]]: + ids_by_type: dict[str, list[str]] = {} + for selected_id in sorted(selected_ids): + resource_type = visible_node_types.get(selected_id) + if not resource_type or resource_type.startswith("CONCEPT::"): + continue + ids_by_type.setdefault(resource_type, []).append(selected_id) + return {resource_type: node_ids for resource_type, node_ids in ids_by_type.items() if len(node_ids) > 1} + + +def _semantic_overview_selected_ids(raw_views: list[dict[str, Any]]) -> set[str]: + for index, view in enumerate(raw_views, start=1): + view_id = view.get("id") + if not isinstance(view_id, str) or not view_id.strip(): + view_id = f"view_{index}" + if view_id.strip() == "overview": + return _semantic_view_selected_ids(view) + return set() + + +def _semantic_edge_endpoint(raw_edge: dict[str, Any], key: str) -> str | None: + value = raw_edge.get(key) + if not isinstance(value, str) or not value.strip(): + value = raw_edge.get(f"{key}_id") + return value.strip() if isinstance(value, str) and value.strip() else None + + +def _semantic_view_isolated_ids( + selected_ids: set[str], + view_edges: list[dict[str, Any]], + visible_node_types: dict[str, str], + containment_parent: dict[str, str], + container_parent: dict[str, str], + group_parents: dict[str, str], +) -> list[str]: + connected_ids: set[str] = set() + for edge in view_edges: + from_id = _semantic_edge_endpoint(edge, "from") + to_id = _semantic_edge_endpoint(edge, "to") + if from_id in selected_ids and to_id in selected_ids: + connected_ids.update((from_id, to_id)) + return sorted( + selected_id + for selected_id in selected_ids - connected_ids + if not _semantic_selected_container_is_connected_boundary( + selected_id, + connected_ids, + visible_node_types, + containment_parent, + container_parent, + group_parents, + ) + ) + + +def _semantic_selected_container_is_connected_boundary( + selected_id: str, + connected_ids: set[str], + visible_node_types: dict[str, str], + containment_parent: dict[str, str], + container_parent: dict[str, str], + group_parents: dict[str, str], +) -> bool: + if selected_id in visible_node_types: + return False + for group_id, parent_id in group_parents.items(): + if group_id in connected_ids and _semantic_container_is_descendant_or_same( + parent_id, selected_id, container_parent + ): + return True + for node_id, parent_id in containment_parent.items(): + if node_id in connected_ids and _semantic_container_is_descendant_or_same( + parent_id, selected_id, container_parent + ): + return True + return False + + +def _needs_overview_with_drilldown_views(architecture_context: dict[str, Any], raw_edges: list[dict[str, Any]]) -> bool: + return _needs_non_network_overview_with_drilldown_views( + architecture_context, + raw_edges, + ) or _needs_network_drilldown_view(architecture_context) + + +def _needs_non_network_overview_with_drilldown_views( + architecture_context: dict[str, Any], raw_edges: list[dict[str, Any]] +) -> bool: + visible_nodes = _list_of_dicts(architecture_context.get("visible_nodes")) + visible_containers = _list_of_dicts(architecture_context.get("containers")) + visible_edges = _list_of_dicts(architecture_context.get("visible_edges")) + semantic_edge_count = len(raw_edges) + visible_element_count = len(visible_nodes) + len(visible_containers) + return visible_element_count > 14 or semantic_edge_count > 6 or len(visible_edges) > 12 + + +def _needs_placement_preserving_overview(architecture_context: dict[str, Any]) -> bool: + visible_nodes = _list_of_dicts(architecture_context.get("visible_nodes")) + if len(visible_nodes) > 10: + return False + domains = _placement_vswitch_domains(architecture_context) + domains_with_core_nodes = [ + domain + for domain in domains + if any(_semantic_type_is_placement_core_node(str(member.get("type") or "")) for member in domain["members"]) + ] + return len(domains_with_core_nodes) >= 2 + + +def _placement_vswitch_domains(architecture_context: dict[str, Any]) -> list[dict[str, Any]]: + containers = { + str(item.get("id")): item + for item in _list_of_dicts(architecture_context.get("containers")) + if isinstance(item.get("id"), str) + } + visible_nodes = { + str(item.get("id")): item + for item in _list_of_dicts(architecture_context.get("visible_nodes")) + if isinstance(item.get("id"), str) + } + members_by_container: dict[str, list[dict[str, Any]]] = {} + for item in _list_of_dicts(architecture_context.get("containment")): + resource_id = item.get("resource") + container_id = item.get("container") + if not isinstance(resource_id, str) or not isinstance(container_id, str): + continue + member = visible_nodes.get(resource_id) + if member is not None: + members_by_container.setdefault(container_id, []).append(_summary_node(member)) + + domains: list[dict[str, Any]] = [] + for container_id, container in containers.items(): + resource_type = str(container.get("type") or "") + if resource_type != "ALIYUN::ECS::VSwitch": + continue + members = members_by_container.get(container_id, []) + if not members: + continue + domain: dict[str, Any] = _summary_node(container) + domain["members"] = members + parent = container.get("parent") + if isinstance(parent, str) and parent: + domain["parent"] = parent + domains.append(domain) + return domains + + +def _semantic_type_is_placement_core_node(resource_type: str) -> bool: + return any( + marker in resource_type + for marker in ( + "::ECS::Instance", + "::ECS::InstanceGroup", + "::RDS::DBInstance", + "::POLARDB::DBCluster", + "::REDIS::", + "::SLB::LoadBalancer", + "::ALB::LoadBalancer", + "::NLB::LoadBalancer", + ) + ) + + +def _needs_network_drilldown_view(architecture_context: dict[str, Any]) -> bool: + network_attachments = _list_of_dicts(architecture_context.get("network_attachments")) + child_types = {str(item.get("child_instance_type") or "").upper() for item in network_attachments} + if len(network_attachments) >= 2 or child_types & {"VPC", "VBR"}: + return True + + resource_like_items = _list_of_dicts(architecture_context.get("visible_nodes")) + _list_of_dicts( + architecture_context.get("containers") + ) + network_control_count = 0 + for item in resource_like_items: + resource_type = str(item.get("type") or "") + if ( + "::CEN::" in resource_type + or "TransitRouter" in resource_type + or "NatGateway" in resource_type + or "Snat" in resource_type + or resource_type.endswith("::Route") + or "RouteTable" in resource_type + ): + network_control_count += 1 + return network_control_count >= 3 + + +def _needs_ack_application_drilldown_view(architecture_context: dict[str, Any]) -> bool: + if not _list_of_dicts(architecture_context.get("kubernetes_applications")): + return False + return len(_ack_application_concept_ids(architecture_context)) >= 2 + + +def _ack_application_concept_ids(architecture_context: dict[str, Any]) -> set[str]: + return { + str(item.get("id")) + for item in _list_of_dicts(architecture_context.get("visible_nodes")) + if isinstance(item.get("id"), str) and str(item.get("type") or "").startswith("CONCEPT::ACK::") + } + + +def _needs_ram_governance_drilldown_view(architecture_context: dict[str, Any]) -> bool: + ram_items = _ram_governance_items(architecture_context) + if len(ram_items) < 6: + return False + ram_type_families = { + _ram_type_family(str(item.get("type") or "")) + for item in ram_items + if _ram_type_family(str(item.get("type") or "")) + } + if len(ram_type_families) < 2: + return False + visible_ram_count = sum( + 1 + for item in _list_of_dicts(architecture_context.get("visible_nodes")) + if _semantic_type_is_ram_governance(str(item.get("type") or "")) + ) + return visible_ram_count >= 2 + + +def _ram_governance_items(architecture_context: dict[str, Any]) -> list[dict[str, Any]]: + resources = _list_of_dicts(architecture_context.get("resources")) + if resources: + return [item for item in resources if _semantic_type_is_ram_governance(str(item.get("type") or ""))] + visible_items = _list_of_dicts(architecture_context.get("visible_nodes")) + _list_of_dicts( + architecture_context.get("concept_nodes") + ) + return [item for item in visible_items if _semantic_type_is_ram_governance(str(item.get("type") or ""))] + + +def _semantic_type_is_ram_governance(resource_type: str) -> bool: + return resource_type.startswith(RAM_GOVERNANCE_TYPE_PREFIX) and ( + resource_type in RAM_GOVERNANCE_CORE_TYPES + or resource_type in RAM_GOVERNANCE_PERMISSION_TYPES + or "Policy" in resource_type + ) + + +def _ram_type_family(resource_type: str) -> str: + if not _semantic_type_is_ram_governance(resource_type): + return "" + if resource_type in { + "ALIYUN::RAM::AccessKey", + "ALIYUN::RAM::User", + "ALIYUN::RAM::UserToGroupAddition", + }: + return "identity" + if resource_type in {"ALIYUN::RAM::Group", "ALIYUN::RAM::Role"}: + return "principal_container" + if resource_type in RAM_GOVERNANCE_PERMISSION_TYPES or "Policy" in resource_type: + return "permission_policy" + return "ram" + + +def _semantic_type_is_permission_scope(resource_type: str) -> bool: + if not resource_type or _semantic_type_is_ram_governance(resource_type): + return False + return any( + marker in resource_type + for marker in ( + "::ECS::", + "::OSS::", + "::RDS::", + "::POLARDB::", + "::REDIS::", + "::NAS::", + "::FC::", + "::ALB::", + "::SLB::", + "::NLB::", + "::VPC::", + ) + ) + + +def _small_network_detail_is_covered_by_overview( + architecture_context: dict[str, Any], + raw_views: list[dict[str, Any]], +) -> bool: + network_attachments = _list_of_dicts(architecture_context.get("network_attachments")) + if not network_attachments: + return False + overview = _semantic_view_by_id(raw_views, "overview") + if overview is None: + return False + selected_ids = _semantic_view_selected_ids(overview) + if len(selected_ids) > 8 or len(_list_of_dicts(overview.get("edges"))) > 6: + return False + + group_members = _semantic_view_group_members(overview) + covered_ids = set(selected_ids) + for group_id in selected_ids: + covered_ids.update(group_members.get(group_id, [])) + marker_to_summary = _attachment_marker_layer_summary_ids(architecture_context) + for marker_id, summary_id in marker_to_summary.items(): + if summary_id in covered_ids: + covered_ids.add(marker_id) + + visible_node_ids = { + str(item.get("id")) + for item in _list_of_dicts(architecture_context.get("visible_nodes")) + if isinstance(item.get("id"), str) + } + visible_node_types = { + str(item.get("id")): str(item.get("type") or "") + for item in _list_of_dicts(architecture_context.get("visible_nodes")) + if isinstance(item.get("id"), str) + } + if len(network_attachments) > 3: + selected_summary_ids = { + selected_id + for selected_id in selected_ids + if visible_node_types.get(selected_id) == "CONCEPT::Layer::AttachmentSummary" + } + return ( + len(visible_node_ids) <= 4 + and visible_node_ids.issubset(covered_ids) + and (len(_list_of_dicts(overview.get("edges"))) > 0 or bool(selected_summary_ids)) + ) + + child_resources = { + str(attachment.get("child_resource")) + for attachment in network_attachments + if attachment.get("type") == "ALIYUN::CEN::CenInstanceAttachment" + and isinstance(attachment.get("child_resource"), str) + and str(attachment.get("child_resource")).strip() + } + if child_resources and not child_resources.issubset(covered_ids): + return False + + cen_config_ids = _semantic_selected_cen_config_ids(architecture_context, covered_ids) + if not cen_config_ids: + return False + + external_attachments = _semantic_external_cen_network_attachments(architecture_context) + if external_attachments: + text_parts: list[str] = [] + for raw_group in _list_of_dicts(overview.get("groups")): + text_parts.append(str(raw_group.get("label") or "")) + for edge in _list_of_dicts(overview.get("edges")): + text_parts.append(str(edge.get("label") or "")) + if not any(_semantic_text_mentions_external_cen_network(text) for text in text_parts): + return False + + return True + + +def _repeated_edge_shape_issues( + architecture_context: dict[str, Any], + accepted_edges: list[dict[str, Any]], +) -> list[str]: + issues: list[str] = [] + visible_node_types = _visible_node_types_by_id(architecture_context) + by_target: dict[tuple[str, str, str], list[str]] = {} + by_source: dict[tuple[str, str, str], list[str]] = {} + for edge in accepted_edges: + from_id = str(edge.get("from") or "") + to_id = str(edge.get("to") or "") + kind = str(edge.get("kind") or "") + label = str(edge.get("label") or "") + if not from_id or not to_id or not label: + continue + by_target.setdefault((to_id, kind, label), []).append(from_id) + by_source.setdefault((from_id, kind, label), []).append(to_id) + for (to_id, _kind, label), source_ids in by_target.items(): + if len(set(source_ids)) >= 3: + if _semantic_repeated_edge_shape_is_expected_network_hub(to_id, label, visible_node_types): + continue + issues.append( + f"too many repeated edges to {to_id} labeled {label}; summarize equivalent fan-in relationships" + ) + for (from_id, _kind, label), target_ids in by_source.items(): + if len(set(target_ids)) >= 3: + if _semantic_repeated_edge_shape_is_expected_network_hub(from_id, label, visible_node_types): + continue + issues.append( + f"too many repeated edges from {from_id} labeled {label}; summarize equivalent fan-out relationships" + ) + return issues + + +def _semantic_repeated_edge_shape_is_expected_network_hub( + node_id: str, + label: str, + visible_node_types: dict[str, str], +) -> bool: + return _semantic_endpoint_is_transit_router( + node_id, visible_node_types + ) and _semantic_label_mentions_vpc_connection(label) + + +def _looks_reversed_scaling_source_edge( + architecture_context: dict[str, Any], + from_id: str, + to_id: str, + label: str, +) -> bool: + node_types = _visible_node_types_by_id(architecture_context) + if node_types.get(from_id) != "ALIYUN::ESS::ScalingGroup": + return False + if node_types.get(to_id) not in {"ALIYUN::ECS::Instance", "ALIYUN::ECS::InstanceGroup"}: + return False + normalized = label.casefold() + return any(marker in normalized for marker in ("基准", "模板", "配置", "config", "template", "source", "base")) + + +def _semantic_scaling_configuration_source_issues( + architecture_context: dict[str, Any], + raw_views: list[dict[str, Any]], + relationship_edges: list[dict[str, Any]], +) -> list[str]: + valid_node_ids = { + str(item.get("id")) + for item in _list_of_dicts(architecture_context.get("visible_nodes")) + if isinstance(item.get("id"), str) + } + selected_ids: set[str] = set() + for view in raw_views: + selected_ids.update(_semantic_view_selected_ids(view)) + relationship_endpoint_ids = _edge_endpoint_ids(relationship_edges) + issues: list[str] = [] + for concept in _list_of_dicts(architecture_context.get("concept_nodes")): + if concept.get("type") != "CONCEPT::ESS::ScaledECS": + continue + scaled_id = concept.get("id") + source_id = concept.get("source") + controller_id = concept.get("controller") + if not ( + isinstance(scaled_id, str) + and scaled_id.strip() + and isinstance(source_id, str) + and source_id.strip() + and isinstance(controller_id, str) + and controller_id.strip() + ): + continue + scaled_id = scaled_id.strip() + source_id = source_id.strip() + controller_id = controller_id.strip() + if source_id not in valid_node_ids or controller_id not in valid_node_ids: + continue + scaling_is_in_plan = bool({controller_id, scaled_id} & (selected_ids | relationship_endpoint_ids)) + if not scaling_is_in_plan: + continue + if _find_existing_edge_index(relationship_edges, source_id, controller_id) is not None: + continue + issues.append( + f"ESS scaling configuration source {source_id}->{controller_id} is missing; " + "draw seed/template ECS -> ESS scaling group with label 伸缩配置" + ) + return issues + + +def _visible_node_types_by_id(architecture_context: dict[str, Any]) -> dict[str, str]: + result: dict[str, str] = {} + for item in _list_of_dicts(architecture_context.get("visible_nodes")): + node_id = item.get("id") + node_type = item.get("type") + if isinstance(node_id, str) and isinstance(node_type, str): + result[node_id] = node_type + return result + + +def _needs_semantic_relationships(architecture_context: dict[str, Any]) -> bool: + visible_nodes = _list_of_dicts(architecture_context.get("visible_nodes")) + explicit_relations = _list_of_dicts(architecture_context.get("explicit_relations")) + concept_nodes = _list_of_dicts(architecture_context.get("concept_nodes")) + if len(visible_nodes) + len(concept_nodes) < 3: + return False + non_containment_relations = [ + relation + for relation in explicit_relations + if relation.get("source_type") != "ALIYUN::ECS::VSwitch" + and relation.get("source_type") != "ALIYUN::ECS::SecurityGroup" + ] + return len(non_containment_relations) >= 2 + + +def _list_of_dicts(value: Any) -> list[dict[str, Any]]: + return [item for item in value if isinstance(item, dict)] if isinstance(value, list) else [] + + +def _node_hint_values_by_id(architecture_context: dict[str, Any]) -> dict[str, tuple[str, ...]]: + result: dict[str, list[str]] = {} + for item in _list_of_dicts(architecture_context.get("node_label_hints")): + node_id = item.get("id") + hints = item.get("hints") + if not isinstance(node_id, str) or not isinstance(hints, dict): + continue + values = [value.strip() for value in hints.values() if isinstance(value, str) and value.strip()] + if values: + result[node_id] = values + return {node_id: tuple(values) for node_id, values in result.items()} + + +def _needs_chinese_role_label(label: str) -> bool: + return bool(label.strip()) and not _contains_cjk(label) + + +def _contains_cjk(value: str) -> bool: + return re.search(r"[\u3400-\u9fff\u3040-\u30ff]", value) is not None + + +def _copies_raw_identifier_hint(label: str, hint_values: tuple[str, ...]) -> bool: + normalized_label = _normalize_identifier(label) + return any(normalized_label == _normalize_identifier(hint) and _looks_identifier_like(hint) for hint in hint_values) + + +def _normalize_identifier(value: str) -> str: + return re.sub(r"[\s_-]+", "", value).casefold() + + +def _looks_identifier_like(value: str) -> bool: + value = value.strip() + if not value: + return False + return bool(re.fullmatch(r"[A-Za-z0-9_-]*[A-Za-z][A-Za-z0-9_-]*\d[A-Za-z0-9_-]*", value)) + + +def render_terminal(console: Console, mermaid_source: str, *, width: int) -> None: + try: + preview_console = Console(width=width) + preview_console.print(_render_terminal_rich(mermaid_source)) + except Exception as exc: + console.print(f"[yellow]termaid render failed, printing Mermaid source instead: {exc}[/]") + console.print(f"```mermaid\n{mermaid_source}\n```") + + +def _terminal_preview_items( + rendered_mermaid_source: str, + rendered_views: ArchitectureMultiViewRenderResult, +) -> list[TerminalPreviewItem]: + if rendered_views.views: + return [ + TerminalPreviewItem( + id=view.id, + title=view.title, + mermaid_source=view.mermaid_source, + ) + for view in rendered_views.views + ] + return [TerminalPreviewItem(id="", title="", mermaid_source=rendered_mermaid_source)] + + +def write_terminal_svg(path: Path, mermaid_source: str, *, width: int, title: str) -> Path: + """Render Mermaid through termaid/Rich and save the terminal view as SVG.""" + + path.parent.mkdir(parents=True, exist_ok=True) + console = Console(width=width, record=True, force_terminal=True, color_system="truecolor", file=io.StringIO()) + console.print(_render_terminal_rich(mermaid_source)) + console.save_svg(str(path), title=title) + return path + + +def write_terminal_png(path: Path, mermaid_source: str, *, width: int, title: str) -> Path: + """Render Mermaid through termaid/Rich and convert the terminal SVG to PNG.""" + + path.parent.mkdir(parents=True, exist_ok=True) + with tempfile.NamedTemporaryFile(suffix=".svg", delete=False) as handle: + svg_path = Path(handle.name) + try: + write_terminal_svg(svg_path, mermaid_source, width=width, title=title) + convert_svg_to_png(svg_path, path) + finally: + svg_path.unlink(missing_ok=True) + return path + + +def write_view_mermaid_files(directory: Path, views: ArchitectureMultiViewRenderResult) -> list[Path]: + """Write one Mermaid source file per architecture view.""" + + directory.mkdir(parents=True, exist_ok=True) + paths: list[Path] = [] + for index, view in enumerate(views.views, start=1): + path = directory / f"{index:02d}-{_safe_view_filename(view.id)}.mmd" + path.write_text(view.mermaid_source, encoding="utf-8") + paths.append(path) + return paths + + +def write_view_terminal_svgs( + directory: Path, + views: ArchitectureMultiViewRenderResult, + *, + width: int, + title: str, +) -> list[Path]: + """Render one Rich terminal SVG per architecture view.""" + + directory.mkdir(parents=True, exist_ok=True) + paths: list[Path] = [] + for index, view in enumerate(views.views, start=1): + path = directory / f"{index:02d}-{_safe_view_filename(view.id)}.terminal.svg" + write_terminal_svg(path, view.mermaid_source, width=width, title=f"{title} - {view.title}") + paths.append(path) + return paths + + +def write_view_terminal_pngs( + directory: Path, + views: ArchitectureMultiViewRenderResult, + *, + width: int, + title: str, +) -> list[Path]: + """Render one Rich terminal PNG per architecture view.""" + + directory.mkdir(parents=True, exist_ok=True) + paths: list[Path] = [] + for index, view in enumerate(views.views, start=1): + path = directory / f"{index:02d}-{_safe_view_filename(view.id)}.terminal.png" + write_terminal_png(path, view.mermaid_source, width=width, title=f"{title} - {view.title}") + paths.append(path) + return paths + + +def record_terminal_preview(args: argparse.Namespace, *, console: Console | None = None) -> None: + """Record the real terminal preview stream and render its final frame to image files.""" + + console = console or Console() + requested_png = args.record_terminal_png_out + requested_gif = args.record_terminal_gif_out + requested_cast = args.record_terminal_cast_out + needs_gif = requested_png is not None or requested_gif is not None + required_commands = ["asciinema"] + if needs_gif: + required_commands.append("agg") + if requested_png is not None: + required_commands.append("ffmpeg") + missing_commands = [command for command in required_commands if shutil.which(command) is None] + if missing_commands: + raise RuntimeError("Missing command(s) for terminal recording: {}".format(", ".join(missing_commands))) + + for path in (requested_png, requested_gif, requested_cast): + if path is not None: + path.expanduser().parent.mkdir(parents=True, exist_ok=True) + + cols = max(1, int(args.record_terminal_cols)) + rows = max(1, int(args.record_terminal_rows)) + with tempfile.TemporaryDirectory(prefix="iac-arch-terminal-record-") as tmp_dir: + tmp_path = Path(tmp_dir) + cast_path = requested_cast.expanduser() if requested_cast is not None else tmp_path / "terminal.cast" + gif_path = requested_gif.expanduser() if requested_gif is not None else tmp_path / "terminal.gif" + png_path = requested_png.expanduser() if requested_png is not None else None + + child_command = _record_terminal_child_command(args, width=cols) + shell_command = _record_terminal_shell_command(child_command) + subprocess.run( + [ + "asciinema", + "rec", + "-q", + "--overwrite", + "--headless", + "--return", + "--window-size", + f"{cols}x{rows}", + "-c", + shell_command, + str(cast_path), + ], + check=True, + ) + if needs_gif: + subprocess.run( + [ + "agg", + "-q", + "--cols", + str(cols), + "--rows", + str(rows), + "--font-size", + str(args.record_terminal_font_size), + "--line-height", + str(args.record_terminal_line_height), + "--theme", + args.record_terminal_theme, + "--select", + "100%", + str(cast_path), + str(gif_path), + ], + check=True, + ) + if png_path is not None: + subprocess.run( + [ + "ffmpeg", + "-y", + "-loglevel", + "error", + "-i", + str(gif_path), + "-frames:v", + "1", + str(png_path), + ], + check=True, + ) + + if requested_cast is not None: + console.print(f"[green]Wrote terminal cast:[/] {requested_cast.expanduser()}") + if requested_gif is not None: + console.print(f"[green]Wrote terminal GIF:[/] {requested_gif.expanduser()}") + if requested_png is not None: + console.print(f"[green]Wrote terminal PNG:[/] {requested_png.expanduser()}") + + +def _record_terminal_child_command(args: argparse.Namespace, *, width: int) -> list[str]: + command = [ + sys.executable, + str(_preview_script_entrypoint()), + str(args.template.expanduser()), + "--quiet", + "--width", + str(width), + "--max-tokens", + str(args.max_tokens), + "--max-attempts", + str(max(1, args.max_attempts)), + ] + if args.model: + command.extend(["--model", args.model]) + if args.enable_thinking: + command.append("--enable-thinking") + for option, value in ( + ("--mermaid-out", args.mermaid_out), + ("--view-mermaid-dir", args.view_mermaid_dir), + ("--plan-out", args.plan_out), + ("--html-out", args.html_out), + ("--prompt-debug-html-out", args.prompt_debug_html_out), + ): + if value is not None: + command.extend([option, str(value.expanduser())]) + return command + + +def _preview_script_entrypoint() -> Path: + source_path = Path(__file__).resolve() + repo_root = source_path.parents[4] + script_path = repo_root / "scripts" / "rendering" / "preview_template_architecture_llm.py" + if script_path.exists(): + return script_path + return source_path + + +def _record_terminal_shell_command(command: list[str]) -> str: + child = shlex.join(["env", "TERM=xterm-256color", "COLORTERM=truecolor", "FORCE_COLOR=1", *command]) + hide_cursor = shlex.quote("\033[?25l") + show_cursor = shlex.quote("\033[?25h") + return f'printf {hide_cursor}; {child}; status=$?; printf {show_cursor}; exit "$status"' + + +def _safe_view_filename(value: str) -> str: + filename = re.sub(r"[^A-Za-z0-9_.-]+", "-", value.strip()).strip(".-") + return filename or "view" + + +def convert_svg_to_png(svg_path: Path, png_path: Path) -> None: + """Convert an SVG file to PNG with a locally available command-line converter.""" + + png_path.parent.mkdir(parents=True, exist_ok=True) + command = _svg_to_png_command(svg_path, png_path) + if command is None: + raise RuntimeError("No SVG to PNG converter found. Install rsvg-convert, ImageMagick, or use macOS sips.") + subprocess.run(command, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) + + +def _svg_to_png_command(svg_path: Path, png_path: Path) -> list[str] | None: + if shutil.which("rsvg-convert"): + return ["rsvg-convert", str(svg_path), "-o", str(png_path)] + if shutil.which("magick"): + return ["magick", str(svg_path), str(png_path)] + if shutil.which("convert"): + return ["convert", str(svg_path), str(png_path)] + if shutil.which("sips"): + return ["sips", "-s", "format", "png", str(svg_path), "--out", str(png_path)] + return None + + +def _render_terminal_rich(mermaid_source: str) -> Any: + render_rich = import_module("termaid").render_rich + + return style_attachment_lines(render_rich(mermaid_source)) + + +def browser_mermaid_source(mermaid_source: str) -> str: + """Convert terminal-friendly Mermaid to browser Mermaid v11-friendly syntax.""" + + def replace_subgraph(match: re.Match[str]) -> str: + indent, subgraph_id, label = match.group(1), match.group(2), match.group(3) + return '{}subgraph {}["{}"]'.format(indent, subgraph_id, label.replace('"', "#quot;")) + + return re.sub( + r"^(\s*)subgraph\s+([A-Za-z0-9_]+)\s+\[(.+?)\]\s*$", + replace_subgraph, + mermaid_source, + flags=re.M, + ) + + +def write_html(path: Path | None, *, title: str, mermaid_source: str, open_browser: bool) -> Path: + browser_source = html.escape(browser_mermaid_source(mermaid_source)) + if path is None: + handle = tempfile.NamedTemporaryFile("w", suffix=".html", delete=False, encoding="utf-8") + with handle: + output_path = Path(handle.name) + handle.write(HTML_TEMPLATE.format(title=html.escape(title), mermaid=browser_source)) + else: + output_path = path + output_path.parent.mkdir(parents=True, exist_ok=True) + output_path.write_text(HTML_TEMPLATE.format(title=html.escape(title), mermaid=browser_source), encoding="utf-8") + if open_browser: + webbrowser.open(f"file://{output_path}") + return output_path + + +def write_prompt_debug_html( + path: Path, + *, + title: str, + model: str, + records: list[dict[str, Any]], + timings: dict[str, float], +) -> Path: + path.parent.mkdir(parents=True, exist_ok=True) + rows = "\n".join(_prompt_debug_row(record) for record in records) + attempts = "\n".join(_prompt_debug_attempt_section(record) for record in records) + metrics = "\n".join( + _prompt_debug_metric(label, value) + for label, value in ( + ("Attempts", str(len(records))), + ("LLM Time", _format_elapsed(timings.get("llm", 0.0))), + ("Total Time", _format_elapsed(timings.get("total", 0.0))), + ("Total Prompt Chars", str(sum(int(record.get("prompt_chars") or 0) for record in records))), + ( + "Total Cache Read Tokens", + str(sum(int(record.get("cache_read_input_tokens") or 0) for record in records)), + ), + ) + ) + page = PROMPT_DEBUG_HTML_TEMPLATE.format( + title=html.escape(f"Prompt Debug: {title}"), + model=html.escape(model), + generated_at=html.escape(time.strftime("%Y-%m-%d %H:%M:%S %z")), + metrics=metrics, + rows=rows, + attempts=attempts, + ) + path.write_text(page, encoding="utf-8") + return path + + +def _prompt_debug_metric(label: str, value: str) -> str: + return f'
{html.escape(label)}{html.escape(value)}
' + + +def _prompt_debug_row(record: dict[str, Any]) -> str: + return ( + "" + f"{html.escape(str(record.get('attempt') or ''))}" + f"{_prompt_debug_selected(record)}" + f"{html.escape(_format_elapsed(float(record.get('llm_seconds') or 0.0)))}" + f"{html.escape(str(record.get('prompt_chars') or 0))}" + f"{html.escape(str(record.get('cacheable_prefix_chars') or 0))}" + f"{html.escape(str(len(record.get('sent_validation_issues') or [])))}" + f"{html.escape(str(len(record.get('validation_issues') or [])))}" + f"{html.escape(str(record.get('cache_read_input_tokens') or 0))}" + f"{html.escape(str(record.get('raw_output_chars') or len(str(record.get('raw_output') or ''))))}" + "" + ) + + +def _prompt_debug_selected(record: dict[str, Any]) -> str: + if record.get("selected"): + return 'selected' + return "" + + +def _prompt_debug_attempt_section(record: dict[str, Any]) -> str: + attempt = html.escape(str(record.get("attempt") or "")) + selected = ' selected' if record.get("selected") else "" + sent_issues = _prompt_debug_issue_list(record.get("sent_validation_issues")) + result_issues = _prompt_debug_issue_list(record.get("validation_issues")) + system_prompt = str(record.get("system_prompt") or "") + user_prompt = str(record.get("user_prompt") or "") + messages = record.get("messages") + if not isinstance(messages, list): + messages = [{"role": "user", "content": user_prompt}] + prompt_order = _prompt_debug_prompt_order(system_prompt, messages) + full_request_prompt = _prompt_debug_full_request_prompt(system_prompt, messages) + return f""" +
+

Attempt {attempt}{selected}

+
+ {_prompt_debug_metric("LLM Time", _format_elapsed(float(record.get("llm_seconds") or 0.0)))} + {_prompt_debug_metric("System Prompt Chars", str(record.get("system_prompt_chars") or 0))} + {_prompt_debug_metric("User Prompt Chars", str(record.get("user_prompt_chars") or 0))} + {_prompt_debug_metric("Cacheable Prefix Chars", str(record.get("cacheable_prefix_chars") or 0))} + {_prompt_debug_metric("Common Prefix With Previous", str(record.get("common_prefix_with_previous_chars") or 0))} + {_prompt_debug_metric("Total Prompt Chars", str(record.get("prompt_chars") or 0))} + {_prompt_debug_metric("Input Tokens", str(record.get("input_tokens") or 0))} + {_prompt_debug_metric("Output Tokens", str(record.get("output_tokens") or 0))} + {_prompt_debug_metric("Cache Read Tokens", str(record.get("cache_read_input_tokens") or 0))} + {_prompt_debug_metric("Cache Create Tokens", str(record.get("cache_creation_input_tokens") or 0))} + {_prompt_debug_metric("Parse Error", str(record.get("parse_error") or "None"))} + {_prompt_debug_metric("Raw Output Chars", str(record.get("raw_output_chars") or 0))} +
+
+ Prompt Sent Order + {prompt_order} +
+
+ Full Request Prompt + 
{html.escape(full_request_prompt)}
+
+
+ Sent Validation Issues ({len(record.get("sent_validation_issues") or [])}) + {sent_issues} +
+
+ Result Validation Issues ({len(record.get("validation_issues") or [])}) + {result_issues} +
+
+ Raw LLM Output + 
{html.escape(str(record.get("raw_output") or ""))}
+
+
+""" + + +def _prompt_debug_full_request_prompt(system_prompt: str, messages: list[Any]) -> str: + parts = [f"system:\n{system_prompt}"] + for message in messages: + if not isinstance(message, dict): + continue + role = str(message.get("role") or "message") + content = str(message.get("content") or "") + parts.append(f"{role}:\n{content}") + return "\n\n".join(parts) + + +def _prompt_debug_prompt_order(system_prompt: str, messages: list[Any]) -> str: + steps: list[str] = [] + step_index = 1 + user_index = 0 + assistant_index = 0 + steps.append(_prompt_debug_prompt_step(f"{step_index}. System Prompt", system_prompt)) + step_index += 1 + for message in messages: + if not isinstance(message, dict): + continue + role = str(message.get("role") or "") + content = str(message.get("content") or "") + if role == "user": + user_index += 1 + cacheable_prompt, dynamic_prompt = split_by_dynamic_boundary(content) + if dynamic_prompt: + steps.append( + _prompt_debug_prompt_step( + f"{step_index}. User Message {user_index} Cacheable Prefix", + cacheable_prompt, + ) + ) + step_index += 1 + steps.append(_prompt_debug_prompt_step(f"{step_index}. Dynamic Boundary", DYNAMIC_BOUNDARY)) + step_index += 1 + steps.append( + _prompt_debug_prompt_step( + f"{step_index}. User Message {user_index} Dynamic Instruction", + dynamic_prompt, + open_by_default=True, + ) + ) + step_index += 1 + else: + steps.append( + _prompt_debug_prompt_step( + f"{step_index}. User Message {user_index}", + content, + open_by_default=True, + ) + ) + step_index += 1 + elif role == "assistant": + assistant_index += 1 + steps.append(_prompt_debug_prompt_step(f"{step_index}. Assistant Message {assistant_index}", content)) + step_index += 1 + else: + steps.append(_prompt_debug_prompt_step(f"{step_index}. {role or 'Message'}", content)) + step_index += 1 + return "\n".join(steps) + + +def _prompt_debug_prompt_step(title: str, content: str, *, open_by_default: bool = False) -> str: + open_attr = " open" if open_by_default else "" + return ( + f'
' + f"{html.escape(title)}" + f"
{html.escape(content)}
" + "
" + ) + + +def _prompt_debug_issue_list(value: Any) -> str: + issues = value if isinstance(value, list) else [] + if not issues: + return '
None
' + items = "\n".join(f'
  • {html.escape(str(issue))}
    • ' for issue in issues) + return f"
      {items}
    " + + +def _message_text(message: Message) -> str: + if isinstance(message.content, str): + return message.content + parts: list[str] = [] + for block in message.content: + text = getattr(block, "text", None) + if isinstance(text, str): + parts.append(text) + content = getattr(block, "content", None) + if isinstance(content, str): + parts.append(content) + return "".join(parts) + + +def _message_debug_dict(message: Message) -> dict[str, str]: + return {"role": message.role, "content": _message_text(message)} + + +def _prompt_request_text(system_prompt: str, messages: list[Message]) -> str: + parts = [f"system:\n{system_prompt}"] + for message in messages: + parts.append(f"{message.role}:\n{_message_text(message)}") + return "\n\n".join(parts) + + +def _cacheable_message_prefix_chars(messages: list[Message]) -> int: + total = 0 + for message in messages: + if message.role != "user": + continue + cacheable_prompt, dynamic_prompt = split_by_dynamic_boundary(_message_text(message)) + if dynamic_prompt: + total += len(cacheable_prompt) + return total + + +def parse_args(argv: list[str]) -> argparse.Namespace: + parser = argparse.ArgumentParser(description="Render a ROS template architecture diagram with real LLM semantics.") + parser.add_argument("template", type=Path, help="ROS template YAML file path.") + parser.add_argument("--model", default=None, help="Override model. Defaults to saved iac-code model.") + parser.add_argument("--max-tokens", type=int, default=3000, help="Max tokens for the semantic plan. Default: 3000.") + parser.add_argument( + "--max-attempts", + type=int, + default=MAX_SEMANTIC_PLAN_ATTEMPTS, + help="Max LLM validation attempts. Default: 3.", + ) + parser.add_argument("--width", type=int, default=180, help="Terminal render width. Default: 180.") + parser.add_argument("--print-facts", action="store_true", help="Print the fact bundle sent to the LLM.") + parser.add_argument("--print-raw", action="store_true", help="Print raw LLM output.") + parser.add_argument( + "--quiet", + action="store_true", + help=( + "Suppress verbose validation, semantic_plan, and Mermaid dumps; still writes outputs and renders previews." + ), + ) + parser.add_argument("--no-terminal", action="store_true", help="Skip termaid terminal rendering.") + parser.add_argument("--mermaid-out", type=Path, default=None, help="Write final Mermaid source to this file.") + parser.add_argument("--view-mermaid-dir", type=Path, default=None, help="Write per-view Mermaid sources here.") + parser.add_argument("--plan-out", type=Path, default=None, help="Write parsed LLM semantic_plan JSON to this file.") + parser.add_argument("--terminal-svg-out", type=Path, default=None, help="Write Rich terminal SVG to this file.") + parser.add_argument("--terminal-png-out", type=Path, default=None, help="Write Rich terminal PNG to this file.") + parser.add_argument("--terminal-svg-dir", type=Path, default=None, help="Write per-view Rich terminal SVGs here.") + parser.add_argument("--terminal-png-dir", type=Path, default=None, help="Write per-view Rich terminal PNGs here.") + parser.add_argument( + "--record-terminal-png-out", + type=Path, + default=None, + help="Record the real terminal preview with asciinema/agg and write the final frame PNG.", + ) + parser.add_argument( + "--record-terminal-gif-out", + type=Path, + default=None, + help="Record the real terminal preview with asciinema/agg and write the final frame GIF.", + ) + parser.add_argument( + "--record-terminal-cast-out", + type=Path, + default=None, + help="Write the asciinema cast used for terminal preview image rendering.", + ) + parser.add_argument( + "--record-terminal-cols", + type=int, + default=220, + help="Recording terminal width in columns. Default: 220.", + ) + parser.add_argument( + "--record-terminal-rows", + type=int, + default=140, + help="Recording terminal height in rows. Default: 140.", + ) + parser.add_argument( + "--record-terminal-font-size", + type=int, + default=16, + help="agg font size in pixels. Default: 16.", + ) + parser.add_argument( + "--record-terminal-line-height", + default="1.25", + help="agg line-height value. Default: 1.25.", + ) + parser.add_argument( + "--record-terminal-theme", + default="github-dark", + help="agg color theme. Default: github-dark.", + ) + parser.add_argument("--html-out", type=Path, default=None, help="Write Mermaid HTML preview to this file.") + parser.add_argument( + "--prompt-debug-html-out", + type=Path, + default=None, + help="Write an HTML report containing the exact system/user prompt sent for every LLM attempt.", + ) + parser.add_argument( + "--enable-thinking", + action="store_true", + help=( + "Use the saved provider thinking/effort setting. By default this preview disables thinking when supported." + ), + ) + parser.add_argument("--open-html", action="store_true", help="Open HTML preview in the default browser.") + return parser.parse_args(argv) + + +def _record_terminal_requested(args: argparse.Namespace) -> bool: + return any( + path is not None + for path in ( + args.record_terminal_png_out, + args.record_terminal_gif_out, + args.record_terminal_cast_out, + ) + ) + + +def _format_elapsed(seconds: float) -> str: + if seconds < 1: + return f"{seconds * 1000:.0f}ms" + return f"{seconds:.1f}s" + + +def format_timing_summary(timings: dict[str, float]) -> str: + labels = { + "load_and_facts": "load/facts", + "llm": "llm", + "validate": "validate/render", + "select_plan": "select plan", + "views": "views", + "write_outputs": "write outputs", + "terminal_preview": "terminal preview", + "total": "total", + } + parts = [] + for key in ( + "load_and_facts", + "llm", + "validate", + "select_plan", + "views", + "write_outputs", + "terminal_preview", + "total", + ): + if key in timings: + parts.append(f"{labels[key]}={_format_elapsed(timings[key])}") + return "timing: " + ", ".join(parts) + + +async def async_main(argv: list[str]) -> int: + started_at = time.perf_counter() + timings: dict[str, float] = {} + setup_i18n() + args = parse_args(argv) + console = Console() + template_path = args.template.expanduser() + if not template_path.is_file(): + console.print(f"[red]Template file does not exist: {template_path}[/]") + return 1 + if _record_terminal_requested(args): + try: + record_terminal_preview(args, console=console) + except (RuntimeError, subprocess.CalledProcessError) as exc: + console.print(f"[red]Terminal recording failed: {exc}[/]") + return 1 + return 0 + + phase_started = time.perf_counter() + template_content = template_path.read_text(encoding="utf-8") + base_result = render_ros_template_architecture(template_content) + llm_architecture_context = build_llm_architecture_context(base_result.architecture_context) + model = args.model or load_saved_model() or DEFAULT_MODEL + effort_override = None if args.enable_thinking else "none" + timings["load_and_facts"] = time.perf_counter() - phase_started + + console.print(f"[dim]Template:[/] {template_path}") + console.print(f"[dim]Model:[/] {model}") + if effort_override == "none": + console.print("[dim]Thinking:[/] disabled for this preview request") + if args.print_facts: + console.print("[bold]--- FACT BUNDLE ---[/]") + console.print_json(json.dumps(llm_architecture_context, ensure_ascii=False)) + + max_attempts = max(1, args.max_attempts) + raw_output = "" + semantic_plan: dict[str, Any] = {} + rendered = base_result + validation_issues: list[str] = [] + attempt_records: list[dict[str, Any]] = [] + prompt_debug_records: list[dict[str, Any]] = [] + best_raw_output = "" + best_semantic_plan: dict[str, Any] = {} + best_rendered = base_result + best_validation_issues: list[str] | None = None + best_attempt = 0 + llm_elapsed = 0.0 + validate_elapsed = 0.0 + conversation_messages: list[Message] = [] + previous_request_text = "" + for attempt in range(1, max_attempts + 1): + sent_validation_issues = list(validation_issues) + sent_previous_plan = None + user_prompt = build_semantic_plan_user_prompt( + llm_architecture_context, + attempt=attempt, + previous_plan=sent_previous_plan, + validation_issues=sent_validation_issues, + include_fact_bundle=attempt == 1, + include_previous_plan=False, + ) + request_messages = [*conversation_messages, Message.user(user_prompt)] + request_text = _prompt_request_text(SYSTEM_PROMPT, request_messages) + common_prefix_chars = 0 + if previous_request_text: + for left, right in zip(previous_request_text, request_text): + if left != right: + break + common_prefix_chars += 1 + prompt_debug_record: dict[str, Any] = { + "attempt": attempt, + "system_prompt": SYSTEM_PROMPT, + "user_prompt": user_prompt, + "messages": [_message_debug_dict(message) for message in request_messages], + "system_prompt_chars": len(SYSTEM_PROMPT), + "user_prompt_chars": len(user_prompt), + "cacheable_prefix_chars": _cacheable_message_prefix_chars(request_messages), + "common_prefix_with_previous_chars": common_prefix_chars, + "prompt_chars": len(SYSTEM_PROMPT) + sum(len(_message_text(message)) for message in request_messages), + "sent_validation_issues": sent_validation_issues, + "sent_previous_plan": sent_previous_plan, + } + prompt_debug_records.append(prompt_debug_record) + phase_started = time.perf_counter() + raw_output, parsed_semantic_plan, usage, parse_error = await create_semantic_plan_with_llm( + llm_architecture_context, + model=model, + max_tokens=args.max_tokens, + effort_override=effort_override, + user_prompt=user_prompt, + messages=request_messages, + attempt=attempt, + previous_plan=sent_previous_plan, + validation_issues=sent_validation_issues, + ) + previous_request_text = request_text + conversation_messages = [*request_messages, Message.assistant_text(raw_output)] + attempt_llm_elapsed = time.perf_counter() - phase_started + llm_elapsed += attempt_llm_elapsed + prompt_debug_record["llm_seconds"] = attempt_llm_elapsed + prompt_debug_record["input_tokens"] = getattr(usage, "input_tokens", 0) or 0 + prompt_debug_record["output_tokens"] = getattr(usage, "output_tokens", 0) or 0 + prompt_debug_record["cache_creation_input_tokens"] = getattr(usage, "cache_creation_input_tokens", 0) or 0 + prompt_debug_record["cache_read_input_tokens"] = getattr(usage, "cache_read_input_tokens", 0) or 0 + prompt_debug_record["raw_output"] = raw_output + prompt_debug_record["raw_output_chars"] = len(raw_output) + prompt_debug_record["parse_error"] = parse_error + if parsed_semantic_plan is None: + semantic_plan = {} + validation_issues = [f"LLM output was not valid semantic_plan JSON: {parse_error}"] + prompt_debug_record["validation_issues"] = list(validation_issues) + attempt_records.append({"attempt": attempt, "issues": validation_issues, "parse_error": parse_error}) + if not should_retry_semantic_plan_attempt(attempt, max_attempts, validation_issues): + break + continue + semantic_plan = repair_semantic_plan_locally(base_result.architecture_context, parsed_semantic_plan) + if semantic_plan != parsed_semantic_plan: + prompt_debug_record["locally_repaired"] = True + phase_started = time.perf_counter() + rendered = render_ros_template_architecture(template_content, semantic_plan=semantic_plan) + validation_issues = validate_semantic_plan_result( + base_result.architecture_context, + semantic_plan, + rendered.architecture_context, + ) + prompt_debug_record["validation_issues"] = list(validation_issues) + validate_elapsed += time.perf_counter() - phase_started + attempt_records.append({"attempt": attempt, "issues": validation_issues}) + if best_validation_issues is None or validation_issue_score(validation_issues) < validation_issue_score( + best_validation_issues + ): + best_raw_output = raw_output + best_semantic_plan = semantic_plan + best_rendered = rendered + best_validation_issues = validation_issues + best_attempt = attempt + if not should_retry_semantic_plan_attempt(attempt, max_attempts, validation_issues): + break + timings["llm"] = llm_elapsed + timings["validate"] = validate_elapsed + phase_started = time.perf_counter() + if best_attempt: + raw_output = best_raw_output + semantic_plan = best_semantic_plan + rendered = best_rendered + validation_issues = best_validation_issues or [] + for record in attempt_records: + record["selected"] = record["attempt"] == best_attempt + for record in prompt_debug_records: + record["selected"] = record["attempt"] == best_attempt + timings["select_plan"] = time.perf_counter() - phase_started + + if args.print_raw: + console.print("[bold]--- RAW LLM OUTPUT ---[/]") + console.print(raw_output) + phase_started = time.perf_counter() + rendered_views = render_ros_template_architecture_views(template_content, semantic_plan=semantic_plan) + timings["views"] = time.perf_counter() - phase_started + if not args.quiet: + console.print("[bold]--- VALIDATION ATTEMPTS ---[/]") + console.print_json(json.dumps(attempt_records, ensure_ascii=False)) + console.print("[bold]--- PARSED semantic_plan ---[/]") + console.print_json(json.dumps(semantic_plan, ensure_ascii=False)) + console.print("[bold]--- ACCEPTED / REJECTED ---[/]") + console.print_json(json.dumps(rendered.architecture_context["semantic_plan"], ensure_ascii=False)) + console.print("[bold]--- MERMAID ---[/]") + console.print(rendered.mermaid_source) + if rendered_views.views: + console.print("[bold]--- MERMAID VIEWS ---[/]") + for view in rendered_views.views: + console.print(f"[cyan]{view.title}[/] [dim]({view.id})[/]") + console.print(view.mermaid_source) + else: + selected_attempt = next((record["attempt"] for record in attempt_records if record.get("selected")), None) + selected_attempt = selected_attempt or (attempt_records[-1]["attempt"] if attempt_records else 0) + console.print(f"[dim]LLM attempts:[/] {len(attempt_records)} [dim]selected:[/] {selected_attempt}") + if validation_issues: + console.print(f"[yellow]Validation issues kept:[/] {len(validation_issues)}") + + phase_started = time.perf_counter() + if args.plan_out is not None: + args.plan_out.parent.mkdir(parents=True, exist_ok=True) + args.plan_out.write_text(json.dumps(semantic_plan, ensure_ascii=False, indent=2), encoding="utf-8") + console.print(f"[green]Wrote semantic plan:[/] {args.plan_out}") + if args.mermaid_out is not None: + args.mermaid_out.parent.mkdir(parents=True, exist_ok=True) + args.mermaid_out.write_text(rendered.mermaid_source, encoding="utf-8") + console.print(f"[green]Wrote Mermaid:[/] {args.mermaid_out}") + if args.view_mermaid_dir is not None: + paths = write_view_mermaid_files(args.view_mermaid_dir, rendered_views) + console.print(f"[green]Wrote {len(paths)} Mermaid views:[/] {args.view_mermaid_dir}") + if args.html_out is not None or args.open_html: + html_path = write_html( + args.html_out, + title=template_path.name, + mermaid_source=rendered.mermaid_source, + open_browser=args.open_html, + ) + console.print(f"[green]Wrote HTML preview:[/] {html_path}") + if args.prompt_debug_html_out is not None: + timings["total"] = time.perf_counter() - started_at + prompt_debug_path = write_prompt_debug_html( + args.prompt_debug_html_out, + title=template_path.name, + model=model, + records=prompt_debug_records, + timings=timings, + ) + console.print(f"[green]Wrote prompt debug HTML:[/] {prompt_debug_path}") + if args.terminal_svg_out is not None: + write_terminal_svg( + args.terminal_svg_out, + rendered.mermaid_source, + width=args.width, + title=template_path.name, + ) + console.print(f"[green]Wrote terminal SVG:[/] {args.terminal_svg_out}") + if args.terminal_png_out is not None: + write_terminal_png( + args.terminal_png_out, + rendered.mermaid_source, + width=args.width, + title=template_path.name, + ) + console.print(f"[green]Wrote terminal PNG:[/] {args.terminal_png_out}") + if args.terminal_svg_dir is not None: + paths = write_view_terminal_svgs( + args.terminal_svg_dir, + rendered_views, + width=args.width, + title=template_path.name, + ) + console.print(f"[green]Wrote {len(paths)} terminal SVG views:[/] {args.terminal_svg_dir}") + if args.terminal_png_dir is not None: + paths = write_view_terminal_pngs( + args.terminal_png_dir, + rendered_views, + width=args.width, + title=template_path.name, + ) + console.print(f"[green]Wrote {len(paths)} terminal PNG views:[/] {args.terminal_png_dir}") + timings["write_outputs"] = time.perf_counter() - phase_started + phase_started = time.perf_counter() + if not args.no_terminal: + preview_items = _terminal_preview_items(rendered.mermaid_source, rendered_views) + if any(item.id for item in preview_items): + console.print("[bold]--- TERMAID VIEW PREVIEWS ---[/]") + for item in preview_items: + console.print(f"[bold]{item.title}[/] [dim]({item.id})[/]") + render_terminal(console, item.mermaid_source, width=args.width) + else: + console.print("[bold]--- TERMAID PREVIEW ---[/]") + render_terminal(console, preview_items[0].mermaid_source, width=args.width) + timings["terminal_preview"] = time.perf_counter() - phase_started + timings["total"] = time.perf_counter() - started_at + console.print(f"[dim]{format_timing_summary(timings)}[/]") + return 0 + + +def main() -> None: + raise SystemExit(asyncio.run(async_main(sys.argv[1:]))) + + +if __name__ == "__main__": + main() diff --git a/src/iac_code/pipeline/engine/display_replay.py b/src/iac_code/pipeline/engine/display_replay.py index 48619410..432d8999 100644 --- a/src/iac_code/pipeline/engine/display_replay.py +++ b/src/iac_code/pipeline/engine/display_replay.py @@ -6,7 +6,7 @@ import time from dataclasses import dataclass, field from pathlib import Path -from typing import Any +from typing import Any, cast from loguru import logger @@ -27,6 +27,8 @@ class DisplayCandidate: name: str candidate_index: int | None = None mermaid_source: str = "" + diagram_stage: str = "optimized" + diagram_views: list[dict[str, str]] = field(default_factory=list) summary: str = "" cost_items: list[dict[str, Any]] = field(default_factory=list) total_monthly_cost: str = "" @@ -158,6 +160,8 @@ def record_candidate_diagram(self, event: Any, *, step_id: str | None = None) -> "candidate_name": getattr(event, "candidate_name", ""), "candidate_index": getattr(event, "candidate_index", None), "mermaid_source": getattr(event, "mermaid_source", ""), + "diagram_stage": getattr(event, "diagram_stage", "optimized"), + "views": getattr(event, "views", []), }, ) @@ -322,6 +326,8 @@ def reduce( if event_type == "candidate_diagram" and attempt is not None: candidate = self._candidate(attempt, payload) candidate.mermaid_source = str(payload.get("mermaid_source") or "") + candidate.diagram_stage = self._diagram_stage(payload.get("diagram_stage")) + candidate.diagram_views = self._diagram_views(payload.get("views"), candidate.mermaid_source) if attempt.candidate_selection.state == "none": attempt.candidate_selection.state = "preparing" continue @@ -459,6 +465,43 @@ def _candidate_key(payload: dict[str, Any]) -> int | str: pass return str(payload.get("candidate_name") or "") + @staticmethod + def _diagram_stage(value: Any) -> str: + return "draft" if value == "draft" else "optimized" + + @staticmethod + def _diagram_views(value: Any, fallback_mermaid_source: str) -> list[dict[str, str]]: + views: list[dict[str, str]] = [] + if isinstance(value, list): + for index, raw in enumerate(value, start=1): + if not isinstance(raw, dict): + continue + raw_view = cast(dict[str, Any], raw) + mermaid_source = raw_view.get("mermaid_source") or raw_view.get("mermaidSource") + if not isinstance(mermaid_source, str) or not mermaid_source: + continue + view_id = raw_view.get("id") + title = raw_view.get("title") + purpose = raw_view.get("purpose") + views.append( + { + "id": str(view_id or f"view_{index}"), + "title": str(title or view_id or f"Diagram {index}"), + "purpose": str(purpose or ""), + "mermaid_source": mermaid_source, + } + ) + if not views and fallback_mermaid_source: + views.append( + { + "id": "overview", + "title": "Architecture overview", + "purpose": "", + "mermaid_source": fallback_mermaid_source, + } + ) + return views + def _candidate(self, attempt: DisplayAttempt, payload: dict[str, Any]) -> DisplayCandidate: key = self._candidate_key(payload) candidate = attempt.candidate_selection.candidates.get(key) diff --git a/src/iac_code/pipeline/engine/show_diagram_tool.py b/src/iac_code/pipeline/engine/show_diagram_tool.py index db1c9139..9d56e07d 100644 --- a/src/iac_code/pipeline/engine/show_diagram_tool.py +++ b/src/iac_code/pipeline/engine/show_diagram_tool.py @@ -2,126 +2,28 @@ from __future__ import annotations -from collections import Counter +import asyncio +import json from pathlib import Path from typing import Any -import yaml +from loguru import logger from iac_code.i18n import _ +from iac_code.pipeline.engine.architecture_graph import ( + ArchitectureMultiViewRenderResult, + render_ros_template_architecture, + render_ros_template_architecture_views, +) +from iac_code.pipeline.engine.architecture_semantic_planning import ( + create_semantic_plan_for_architecture_with_llm, + repair_semantic_plan_locally, +) from iac_code.tools.base import Tool, ToolContext, ToolResult from iac_code.types.stream_events import DiagramEvent -LAYER_TYPES = frozenset({"VPC", "VSwitch", "SecurityGroup"}) - -HIDDEN_TYPES = frozenset( - { - "SecurityGroupIngress", - "SecurityGroupEgress", - "EIPAssociation", - "BackendServerAttachment", - "Listener", - "VServerGroup", - "Account", - } -) - -def _short_type(full_type: str) -> str: - parts = full_type.split("::") - return parts[-1] if parts else full_type - - -def _service_name(full_type: str) -> str: - parts = full_type.split("::") - return parts[1] if len(parts) >= 2 else "" - - -def _resource_label(short_type: str, service: str) -> str: - labels = { - "Instance": _("ECS instance"), - "InstanceGroup": _("ECS instance group"), - "EIP": _("Elastic IP address"), - "LoadBalancer": _("SLB load balancer"), - "NatGateway": _("NAT gateway"), - "CommonBandwidthPackage": _("Shared bandwidth package"), - "DBInstance": _("Database instance"), - "PrepayDBInstance": _("Database instance"), - } - label = labels.get(short_type) - if label is not None: - return label - return f"{service}::{short_type}" if service else short_type - - -def _layer_base_label(short_type: str, fallback: str) -> str: - labels = { - "VPC": _("VPC"), - "VSwitch": _("VSwitch"), - "SecurityGroup": _("Security group"), - } - return labels.get(short_type, fallback) - - -def _resolve_ref(value: Any) -> str | None: - """Extract Ref target from ``{'Ref': 'xxx'}`` or a plain string.""" - if isinstance(value, dict) and "Ref" in value: - ref = value["Ref"] - return ref if isinstance(ref, str) and not ref.startswith("ALIYUN::") else None - if isinstance(value, str): - return value - return None - - -def _resolve_cidr(value: Any, params: dict) -> str | None: - if isinstance(value, str): - return value - if isinstance(value, dict) and "Ref" in value: - ref = value["Ref"] - if isinstance(ref, str) and ref in params: - default = params[ref].get("Default") - if isinstance(default, str): - return default - return None - - -def _node_sg_ref(props: dict) -> str | None: - """Resolve SecurityGroupId or first element of SecurityGroupIds.""" - ref = _resolve_ref(props.get("SecurityGroupId")) - if ref: - return ref - sg_ids = props.get("SecurityGroupIds", []) - if isinstance(sg_ids, list) and sg_ids: - return _resolve_ref(sg_ids[0]) - return None - - -def _extract_edges(short_type: str, props: dict, resources: dict) -> list[tuple[str, str]]: - """Extract connection edges from hidden (auxiliary) resource types.""" - edges: list[tuple[str, str]] = [] - if short_type == "EIPAssociation": - eip_ref = _resolve_ref(props.get("AllocationId")) - inst_ref = _resolve_ref(props.get("InstanceId")) - if eip_ref and inst_ref and eip_ref in resources and inst_ref in resources: - edges.append((eip_ref, inst_ref)) - elif short_type == "BackendServerAttachment": - lb_ref = _resolve_ref(props.get("LoadBalancerId")) - if lb_ref and lb_ref in resources: - for backend in props.get("BackendServers", []): - server_ref = None - if isinstance(backend, dict): - if "ServerId" in backend: - server_ref = _resolve_ref(backend["ServerId"]) - elif "Fn::GetAtt" in backend: - getatt = backend["Fn::GetAtt"] - if isinstance(getatt, list) and getatt: - server_ref = str(getatt[0]) - if server_ref and server_ref in resources: - edges.append((lb_ref, server_ref)) - return edges - - -def ros_template_to_mermaid(template_yaml: str) -> str: +def ros_template_to_mermaid(template_yaml: str, *, semantic_plan: dict[str, Any] | None = None) -> str: """Convert a ROS YAML template into a Mermaid graph with nested infrastructure layers. VPC / VSwitch / SecurityGroup are rendered as nested subgraphs (container layers). @@ -129,134 +31,7 @@ def ros_template_to_mermaid(template_yaml: str) -> str: Auxiliary resources (SecurityGroupIngress, EIPAssociation, etc.) are hidden; their relationships are expressed as edges between the visible nodes. """ - from iac_code.tools.cloud.aliyun.ros_yaml import ros_yaml_load - - try: - doc = ros_yaml_load(template_yaml) - except yaml.YAMLError: - return "graph TD\n Error[{}]".format(_("YAML parse error")) - - if not isinstance(doc, dict): - return "graph TD" - - resources: dict = doc.get("Resources") or {} - if not resources: - return "graph TD" - - params: dict = doc.get("Parameters") or {} - - # --- classify resources --- - layers: dict[str, dict] = {} - nodes: dict[str, dict] = {} - edges: list[tuple[str, str]] = [] - - for lid, rdef in resources.items(): - if not isinstance(rdef, dict): - continue - full_type = rdef.get("Type", "") - short = _short_type(full_type) - service = _service_name(full_type) - props = rdef.get("Properties") or {} - - if short in LAYER_TYPES: - layers[lid] = {"short": short, "service": service, "props": props} - elif short in HIDDEN_TYPES: - edges.extend(_extract_edges(short, props, resources)) - else: - label = _resource_label(short, service) - nodes[lid] = {"short": short, "service": service, "props": props, "label": label} - - # disambiguate when multiple nodes share the same display label - type_counts: Counter = Counter(n["short"] for n in nodes.values()) - type_seq: Counter = Counter() - for ninfo in nodes.values(): - s = ninfo["short"] - if type_counts[s] > 1: - type_seq[s] += 1 - ninfo["label"] = f"{ninfo['label']} {type_seq[s]}" - - # --- build containment tree --- - layer_parent: dict[str, str] = {} - - for lid, linfo in layers.items(): - if linfo["short"] == "VSwitch": - vpc_ref = _resolve_ref(linfo["props"].get("VpcId")) - if vpc_ref and vpc_ref in layers: - layer_parent[lid] = vpc_ref - - for lid, linfo in layers.items(): - if linfo["short"] != "SecurityGroup": - continue - vpc_ref = _resolve_ref(linfo["props"].get("VpcId")) - member_vswitches: set[str] = set() - for nid, ninfo in nodes.items(): - if _node_sg_ref(ninfo["props"]) == lid: - vs = _resolve_ref(ninfo["props"].get("VSwitchId")) - if vs and vs in layers: - member_vswitches.add(vs) - if len(member_vswitches) == 1: - layer_parent[lid] = member_vswitches.pop() - elif vpc_ref and vpc_ref in layers: - layer_parent[lid] = vpc_ref - - node_parent: dict[str, str] = {} - for nid, ninfo in nodes.items(): - sg_ref = _node_sg_ref(ninfo["props"]) - vs_ref = _resolve_ref(ninfo["props"].get("VSwitchId")) - vpc_ref = _resolve_ref(ninfo["props"].get("VpcId")) - - if sg_ref and sg_ref in layers: - node_parent[nid] = sg_ref - elif vs_ref and vs_ref in layers: - node_parent[nid] = vs_ref - elif vpc_ref and vpc_ref in layers: - node_parent[nid] = vpc_ref - - # --- generate Mermaid --- - lines: list[str] = ["graph TD"] - sg_style_ids: list[str] = [] - - def layer_label(lid: str) -> str: - linfo = layers[lid] - base = _layer_base_label(linfo["short"], lid) - if linfo["short"] in ("VPC", "VSwitch"): - cidr = _resolve_cidr(linfo["props"].get("CidrBlock"), params) - if cidr: - return f"{base} ({cidr})" - return base - - def render_layer(lid: str, indent: str) -> None: - sub_id = f"layer_{lid}" - lines.append(f'{indent}subgraph {sub_id}["{layer_label(lid)}"]') - if layers[lid]["short"] == "SecurityGroup": - sg_style_ids.append(sub_id) - - for child_lid in layers: - if layer_parent.get(child_lid) == lid: - render_layer(child_lid, indent + " ") - - for child_nid in nodes: - if node_parent.get(child_nid) == lid: - lines.append(f'{indent} {child_nid}["{nodes[child_nid]["label"]}"]') - - lines.append(f"{indent}end") - - for lid in layers: - if lid not in layer_parent: - render_layer(lid, " ") - - for nid, ninfo in nodes.items(): - if nid not in node_parent: - lines.append(f' {nid}["{ninfo["label"]}"]') - - for from_id, to_id in edges: - if from_id in nodes and to_id in nodes: - lines.append(f" {from_id} --> {to_id}") - - for sid in sg_style_ids: - lines.append(f" style {sid} stroke-dasharray: 5 5") - - return "\n".join(lines) + return render_ros_template_architecture(template_yaml, semantic_plan=semantic_plan).mermaid_source class ShowArchitectureDiagramTool(Tool): @@ -294,6 +69,21 @@ def input_schema(self) -> dict[str, Any]: "Zero-based candidate index in evaluated_candidates; used to distinguish duplicate names" ), }, + "mode": { + "type": "string", + "enum": ["render", "facts"], + "description": _( + "Use facts to emit an immediate draft diagram and internally optimize it with the LLM; " + "use render to emit a diagram from an explicit semantic_plan." + ), + }, + "semantic_plan": { + "type": "object", + "description": _( + "Optional LLM-generated semantic graph plan. Edges must reference visible node ids from " + "a prior facts response." + ), + }, }, "required": ["file_path", "candidate_name", "candidate_index"], } @@ -301,6 +91,10 @@ def input_schema(self) -> dict[str, Any]: def is_read_only(self, input: dict | None = None) -> bool: return True + @property + def timeout(self) -> float | None: + return 600.0 + def needs_event_queue(self) -> bool: return True @@ -312,25 +106,103 @@ async def execute(self, *, tool_input: dict[str, Any], context: ToolContext) -> try: abs_path = _resolve_cwd_relative_file(context.cwd, file_path) except ValueError as exc: + await _emit_diagram_error_event( + context, + candidate_name=candidate_name, + candidate_index=candidate_index, + message=str(exc), + ) return ToolResult.error(str(exc)) if not abs_path.exists(): - return ToolResult.error(_("Template file does not exist: {file_path}").format(file_path=file_path)) + message = _("Template file does not exist: {file_path}").format(file_path=file_path) + await _emit_diagram_error_event( + context, + candidate_name=candidate_name, + candidate_index=candidate_index, + message=message, + ) + return ToolResult.error(message) template_content = abs_path.read_text(encoding="utf-8") - mermaid_source = ros_template_to_mermaid(template_content) + mode = tool_input.get("mode") + mode = mode if mode in {"render", "facts"} else "render" + semantic_plan = tool_input.get("semantic_plan") + if not isinstance(semantic_plan, dict): + semantic_plan = None + + base_render_result = render_ros_template_architecture_views(template_content) + if mode == "facts": + if context.event_queue is not None: + await context.event_queue.put( + _diagram_event_from_render_result( + candidate_name=candidate_name, + template_content=template_content, + candidate_index=candidate_index, + render_result=base_render_result, + diagram_stage="draft", + ) + ) + + render_result = base_render_result + try: + generated_semantic_plan = await create_semantic_plan_for_architecture_with_llm( + base_render_result.architecture_context, + template_content, + ) + except asyncio.CancelledError: + if context.event_queue is not None: + await context.event_queue.put( + _diagram_event_from_render_result( + candidate_name=candidate_name, + template_content=template_content, + candidate_index=candidate_index, + render_result=base_render_result, + diagram_stage="optimized", + ) + ) + raise + except Exception: + logger.exception("Failed to optimize architecture diagram with the LLM; keeping draft diagram") + else: + if generated_semantic_plan: + render_result = render_ros_template_architecture_views( + template_content, + semantic_plan=generated_semantic_plan, + ) + + if context.event_queue is not None: + await context.event_queue.put( + _diagram_event_from_render_result( + candidate_name=candidate_name, + template_content=template_content, + candidate_index=candidate_index, + render_result=render_result, + diagram_stage="optimized", + ) + ) + return ToolResult.success( + _('Generated and optimized the architecture diagram for "{candidate_name}".').format( + candidate_name=candidate_name + ) + ) + + if semantic_plan is not None: + semantic_plan = repair_semantic_plan_locally(base_render_result.architecture_context, semantic_plan) + render_result = render_ros_template_architecture_views(template_content, semantic_plan=semantic_plan) + else: + render_result = base_render_result if context.event_queue is not None: - event = DiagramEvent( + event = _diagram_event_from_render_result( candidate_name=candidate_name, template_content=template_content, - mermaid_source=mermaid_source, candidate_index=candidate_index, + render_result=render_result, + diagram_stage="optimized", ) await context.event_queue.put(event) else: - from loguru import logger - logger.debug( "{} invoked without event_queue; skipping event emit " "(typically means pipeline mode not active for this tool call)", @@ -352,3 +224,67 @@ def _resolve_cwd_relative_file(cwd: str, file_path: str) -> Path: if not resolved.is_relative_to(root): raise ValueError(_("Template file path cannot escape the working directory")) return resolved + + +async def _emit_diagram_error_event( + context: ToolContext, + *, + candidate_name: str, + candidate_index: int | None, + message: str, +) -> None: + if context.event_queue is None: + return + mermaid_source = _error_diagram_mermaid(message) + await context.event_queue.put( + DiagramEvent( + candidate_name=candidate_name, + template_content="", + mermaid_source=mermaid_source, + candidate_index=candidate_index, + architecture_context={"error": message}, + diagram_stage="optimized", + views=[ + { + "id": "overview", + "title": "overview", + "purpose": "", + "mermaid_source": mermaid_source, + } + ], + ) + ) + + +def _error_diagram_mermaid(message: str) -> str: + label = " ".join(str(message).split()) or "Architecture diagram unavailable" + return "graph TD\n ArchitectureDiagramUnavailable[" + json.dumps(label, ensure_ascii=False) + "]" + + +def _diagram_event_from_render_result( + *, + candidate_name: str, + template_content: str, + candidate_index: int | None, + render_result: ArchitectureMultiViewRenderResult, + diagram_stage: str, +) -> DiagramEvent: + views = [ + { + "id": view.id, + "title": view.title, + "purpose": view.purpose, + "mermaid_source": view.mermaid_source, + } + for view in render_result.views + ] + mermaid_source = views[0]["mermaid_source"] if views else "graph TD" + return DiagramEvent( + candidate_name=candidate_name, + template_content=template_content, + mermaid_source=mermaid_source, + candidate_index=candidate_index, + architecture_context=render_result.architecture_context, + diagram_stage="draft" if diagram_stage == "draft" else "optimized", + views=views, + ) diff --git a/src/iac_code/pipeline/selling/pipeline.yaml b/src/iac_code/pipeline/selling/pipeline.yaml index 2dd6fe29..4ab326bb 100644 --- a/src/iac_code/pipeline/selling/pipeline.yaml +++ b/src/iac_code/pipeline/selling/pipeline.yaml @@ -450,7 +450,7 @@ steps: prompt: prompts/confirm_and_select.a2a.md inject_tools: [] tools: - include: [read_file] + include: [complete_step] exclude: [] conclusion_schema: type: object diff --git a/src/iac_code/pipeline/selling/prompts/confirm_and_select.md b/src/iac_code/pipeline/selling/prompts/confirm_and_select.md index db56acef..935ca080 100644 --- a/src/iac_code/pipeline/selling/prompts/confirm_and_select.md +++ b/src/iac_code/pipeline/selling/prompts/confirm_and_select.md @@ -18,16 +18,23 @@ ### 展示候选方案 -对每个 `failed` 为 `false` 的方案，依次调用以下两个工具： +对每个 `failed` 为 `false` 的方案，先让界面尽快拿到可展示内容；架构图工具会在内部先推送草图，再推送 LLM 优化后的架构图： -#### 1. 生成架构图 -调用 `show_architecture_diagram` 工具： +#### 1. 并行展示架构图和方案详情 + +在同一个工具调用轮次中，同时调用以下两个只读展示工具。不要等待架构图 LLM 优化完成后再展示方案详情。 + +调用一次 `show_architecture_diagram`： - `file_path`：取 `candidate.output_path` - `candidate_name`：取 `candidate.name` - `candidate_index`：该方案在 `evaluated_candidates` 数组中的 0 基下标 +- `mode`：固定为 `"facts"` + +`facts` 模式会立即向界面推送一版无 LLM 语义优化的架构草图，并在工具内部使用同一份模板事实包调用 LLM 生成语义规划；LLM 完成后工具会再次推送优化后的多视图架构图。不要根据工具返回内容自行生成 `semantic_plan`，也不要为同一候选方案再调用第二次 `show_architecture_diagram`。 -#### 2. 展示方案详情 -调用 `show_candidate_detail` 工具： +在 `show_architecture_diagram` 工具返回之前，不要调用 `complete_step`；工具返回表示优化架构图已经推送，或 LLM 失败时已经推送最终回退图。 + +同时调用 `show_candidate_detail` 工具： - `candidate_name`：取 `candidate.name`（必须与架构图的 candidate_name 一致） - `candidate_index`：该方案在 `evaluated_candidates` 数组中的 0 基下标 - `summary`：根据方案内容撰写简洁的方案描述（2-3句话，包含核心产品组合和架构特点） @@ -37,7 +44,8 @@ - `monthly_cost`：月费用（如 "¥200/月"） - `total_monthly_cost`：月度总费用（如 "¥1,234/月"） -- 先为所有方案调用 `show_architecture_diagram`，再为所有方案调用 `show_candidate_detail` +如果多个方案都需要展示，必须对每个方案都调用一次“架构图 + 方案详情”的并行展示；不要为了架构图优化额外阻塞方案详情展示。 + - 不要用文字输出对比表格或方案信息 — 所有展示数据通过上述工具传递 ### 待选择结论 diff --git a/src/iac_code/providers/dashscope_provider.py b/src/iac_code/providers/dashscope_provider.py index aa6c4170..b8c43ad8 100644 --- a/src/iac_code/providers/dashscope_provider.py +++ b/src/iac_code/providers/dashscope_provider.py @@ -30,6 +30,7 @@ ) _RECALLED_MEMORY_REMINDER_PREFIX = f"\n{RECALLED_MEMORY_MARKER}:" +_DISABLE_THINKING_EFFORTS = {"none", "off", "disable", "disabled", "false", "0"} class DashScopeProvider(OpenAIProvider): @@ -93,36 +94,32 @@ def _build_api_messages( api_messages.extend(self._convert_messages(messages)) if explicit_cache_enabled: - self._mark_last_user_message_cacheable(api_messages) + self._mark_user_messages_cacheable(api_messages) return api_messages @staticmethod - def _mark_last_user_message_cacheable(api_messages: list[dict[str, Any]]) -> None: - """Add ``cache_control`` to the last user message in *api_messages*. + def _mark_user_messages_cacheable(api_messages: list[dict[str, Any]]) -> None: + """Add ``cache_control`` to cacheable user message prefixes. This extends the cache prefix to cover all conversation history up to - and including the most recent user turn, so that successive rounds hit - the cached prefix. DashScope allows up to 4 ``cache_control`` markers; - we use one for system-static and one here. + marked user turns. User messages with DYNAMIC_BOUNDARY get their static + prefix marked even when they are not the last user turn. For ordinary + conversations, only the last user message is marked. """ - for msg in reversed(api_messages): + last_plain_user_message: dict[str, Any] | None = None + for msg in api_messages: if msg.get("role") != "user": continue content = msg.get("content") if _is_recalled_memory_reminder(content): continue - if isinstance(content, str): - msg["content"] = [{"type": "text", "text": content, "cache_control": {"type": "ephemeral"}}] - elif isinstance(content, list): - # Content is already a list of blocks — tag the last text block. - for block in reversed(content): - if isinstance(block, dict): - block_dict: dict[str, Any] = cast(dict[str, Any], block) - if block_dict.get("type") == "text": - block_dict["cache_control"] = {"type": "ephemeral"} - break - break + if _content_has_dynamic_boundary(content): + _mark_message_content_cacheable(msg) + else: + last_plain_user_message = msg + if last_plain_user_message is not None: + _mark_message_content_cacheable(last_plain_user_message) # -- Thinking kwargs ------------------------------------------------------- @@ -130,7 +127,8 @@ def _build_thinking_kwargs(self) -> dict[str, Any]: spec = get_thinking_spec(self._PROVIDER_KEY, self._model) if spec.family is not ThinkingFamily.DASHSCOPE: return {} - if self._thinking_disabled(): + effort = normalize_effort(self._effort) + if self._thinking_disabled() or effort in _DISABLE_THINKING_EFFORTS: return {"extra_body": {"enable_thinking": False}} extra_body: dict[str, Any] = {"enable_thinking": True} thinking_budget = self._effective_thinking_budget() @@ -140,7 +138,6 @@ def _build_thinking_kwargs(self) -> dict[str, Any]: kwargs: dict[str, Any] = {"extra_body": extra_body} if not spec.uses_reasoning_effort_param: return kwargs - effort = normalize_effort(self._effort) if effort is None or effort == "auto": return kwargs allowed = {e.value for e in spec.allowed_efforts} @@ -151,6 +148,25 @@ def _build_thinking_kwargs(self) -> dict[str, Any]: return kwargs +def _mark_message_content_cacheable(msg: dict[str, Any]) -> None: + content = msg.get("content") + if isinstance(content, str): + msg["content"] = _cacheable_text_blocks(content) + elif isinstance(content, list): + # Content is already a list of blocks — tag the last text block. + for index in range(len(content) - 1, -1, -1): + block = content[index] + if isinstance(block, dict): + block_dict: dict[str, Any] = cast(dict[str, Any], block) + if block_dict.get("type") == "text": + text = block_dict.get("text") + if isinstance(text, str): + content[index : index + 1] = _cacheable_text_blocks(text) + else: + block_dict["cache_control"] = {"type": "ephemeral"} + break + + def _is_recalled_memory_reminder(content: Any) -> bool: if isinstance(content, str): return content.startswith(_RECALLED_MEMORY_REMINDER_PREFIX) @@ -159,3 +175,25 @@ def _is_recalled_memory_reminder(content: Any) -> bool: if isinstance(block, dict) and str(block.get("text") or "").startswith(_RECALLED_MEMORY_REMINDER_PREFIX): return True return False + + +def _content_has_dynamic_boundary(content: Any) -> bool: + if isinstance(content, str): + return bool(split_by_dynamic_boundary(content)[1]) + if isinstance(content, list): + for block in content: + if isinstance(block, dict) and bool(split_by_dynamic_boundary(str(block.get("text") or ""))[1]): + return True + return False + + +def _cacheable_text_blocks(text: str) -> list[dict[str, Any]]: + static_part, dynamic_part = split_by_dynamic_boundary(text) + blocks: list[dict[str, Any]] = [] + if static_part: + blocks.append({"type": "text", "text": static_part, "cache_control": {"type": "ephemeral"}}) + if dynamic_part: + blocks.append({"type": "text", "text": dynamic_part}) + if not blocks: + blocks.append({"type": "text", "text": text, "cache_control": {"type": "ephemeral"}}) + return blocks diff --git a/src/iac_code/providers/manager.py b/src/iac_code/providers/manager.py index ec67d69b..788b7b06 100644 --- a/src/iac_code/providers/manager.py +++ b/src/iac_code/providers/manager.py @@ -108,9 +108,11 @@ def create_provider( base_url: str | None = None, provider_key_override: str | None = None, request_policy_override: ProviderRequestPolicy | None = None, + effort_override: str | None = None, ) -> Provider: from iac_code.providers.registry import PROVIDER_REGISTRY + request_policy_override = _request_policy_with_effort_override(request_policy_override, effort_override) provider_key = provider_key_override or _detect_provider_name(model) desc = PROVIDER_REGISTRY.get(provider_key) if desc is None: @@ -262,6 +264,32 @@ def _active_request_policy(policy: ProviderRequestPolicy | None) -> ProviderRequ return policy +_LEGACY_DISABLE_EFFORTS = {"none", "off", "disable", "disabled", "false", "0"} + + +def _request_policy_with_effort_override( + policy: ProviderRequestPolicy | None, + effort_override: str | None, +) -> ProviderRequestPolicy | None: + policy = _active_request_policy(policy) + if effort_override is None: + return policy + effort = effort_override.strip() + if not effort: + return policy + thinking_enabled = policy.thinking_enabled if policy is not None else None + if effort.lower() in _LEGACY_DISABLE_EFFORTS: + thinking_enabled = False + return _active_request_policy( + ProviderRequestPolicy( + thinking_enabled=thinking_enabled, + effort=effort, + thinking_budget=policy.thinking_budget if policy is not None else None, + max_completion_tokens=policy.max_completion_tokens if policy is not None else None, + ) + ) + + class ProviderManager: """Manages provider lifecycle, streaming fallback, and model degradation. When streaming fails mid-way: @@ -279,6 +307,7 @@ def __init__( provider_key_override: str | None = None, base_url_override: str | None = None, request_policy_override: ProviderRequestPolicy | None = None, + effort_override: str | None = None, ): self._model = model self._credentials = credentials @@ -286,7 +315,7 @@ def __init__( self._stream_idle_timeout = stream_idle_timeout self._provider_key_override = provider_key_override self._base_url_override = base_url_override - self._request_policy_override = _active_request_policy(request_policy_override) + self._request_policy_override = _request_policy_with_effort_override(request_policy_override, effort_override) # Lazy: first startup may have no active provider yet. Defer errors # until the user actually tries to send a message, so /auth is reachable. self._provider: Provider | None = None @@ -345,6 +374,7 @@ def reconfigure( provider_key_override: str | None = None, base_url_override: str | None = None, request_policy_override: ProviderRequestPolicy | None = None, + effort_override: str | None = None, ) -> None: """Switch model and credentials in place. @@ -357,7 +387,7 @@ def reconfigure( self._credentials = credentials self._provider_key_override = provider_key_override self._base_url_override = base_url_override - self._request_policy_override = _active_request_policy(request_policy_override) + self._request_policy_override = _request_policy_with_effort_override(request_policy_override, effort_override) self._provider = None try: self._provider = create_provider( diff --git a/src/iac_code/types/stream_events.py b/src/iac_code/types/stream_events.py index a489701f..39e79be6 100644 --- a/src/iac_code/types/stream_events.py +++ b/src/iac_code/types/stream_events.py @@ -10,6 +10,12 @@ from dataclasses import dataclass, field from typing import Any, Literal, Union +TOOL_RENDER_METADATA_KEY = "_iac_code_tool_render" +TOOL_RENDER_DISPLAY_NAME_KEY = "display_name" +TOOL_RENDER_RESULT_COMPACT_KEY = "result_compact" +TOOL_RENDER_RESULT_VERBOSE_KEY = "result_verbose" +TOOL_RENDER_VERBOSE_RESULT_IN_TRANSCRIPT_KEY = "render_verbose_result_in_transcript" + @dataclass class Usage: @@ -58,7 +64,7 @@ class ToolUseStartEvent: tool_use_id: str name: str - renderer_tool: Any | None = field(default=None, repr=False, compare=False) + metadata: dict[str, Any] | None = None type: Literal["tool_use_start"] = "tool_use_start" @@ -282,6 +288,9 @@ class DiagramEvent(ToolEmittedEvent): template_content: str mermaid_source: str candidate_index: int | None = None + architecture_context: dict[str, Any] | None = None + diagram_stage: Literal["draft", "optimized"] = "optimized" + views: list[dict[str, str]] = field(default_factory=list) type: Literal["diagram"] = "diagram" diff --git a/src/iac_code/ui/components/candidate_selection.py b/src/iac_code/ui/components/candidate_selection.py index b96f0cb6..ae1d7870 100644 --- a/src/iac_code/ui/components/candidate_selection.py +++ b/src/iac_code/ui/components/candidate_selection.py @@ -15,8 +15,9 @@ from iac_code.i18n import _ from iac_code.ui.core.key_event import KeyEvent +from iac_code.ui.diagram_rendering import style_attachment_lines -CHROME_LINES = 5 +SCROLL_INDICATOR_LINES = 2 @dataclass @@ -32,6 +33,16 @@ class CandidateDetailEntry: total_monthly_cost: str +@dataclass +class CandidateDiagramView: + """One architecture diagram view inside a candidate tab.""" + + view_id: str + title: str + mermaid_source: str + purpose: str = "" + + @dataclass(frozen=True) class CandidateSelection: """Structured selection returned by the candidate selection UI.""" @@ -49,6 +60,9 @@ class CandidateTab: candidate_name: str candidate_index: int | None = None mermaid_source: str | None = None + diagram_stage: str = "optimized" + diagram_views: list[CandidateDiagramView] = field(default_factory=list) + selected_diagram_view_index: int = 0 summary: str | None = None cost_items: list[dict] = field(default_factory=list) total_monthly_cost: str = "" @@ -113,6 +127,13 @@ def seed_candidates(self, candidates: list[dict[str, Any]]) -> None: def _merge_tab_data(self, target: CandidateTab, source: CandidateTab) -> None: if target.mermaid_source is None and source.mermaid_source is not None: target.mermaid_source = source.mermaid_source + if not target.diagram_views and source.diagram_views: + target.diagram_views = list(source.diagram_views) + target.selected_diagram_view_index = min( + source.selected_diagram_view_index, + max(len(target.diagram_views) - 1, 0), + ) + target.diagram_stage = source.diagram_stage if target.summary is None and source.summary is not None: target.summary = source.summary if not target.cost_items and source.cost_items: @@ -160,9 +181,21 @@ def _get_or_create_tab(self, candidate_name: str, candidate_index: int | None = self._by_key[key] = tab return tab - def add_diagram(self, candidate_name: str, mermaid_source: str, candidate_index: int | None = None) -> None: + def add_diagram( + self, + candidate_name: str, + mermaid_source: str, + candidate_index: int | None = None, + *, + views: list[dict[str, Any]] | None = None, + diagram_stage: str = "optimized", + ) -> None: tab = self._get_or_create_tab(candidate_name, candidate_index) + previous_view_id = self._active_diagram_view(tab).view_id if tab.diagram_views else "" tab.mermaid_source = mermaid_source + tab.diagram_stage = "draft" if diagram_stage == "draft" else "optimized" + tab.diagram_views = self._normalize_diagram_views(views, mermaid_source) + tab.selected_diagram_view_index = self._view_index_by_id(tab.diagram_views, previous_view_id) def update_streaming_summary( self, @@ -220,6 +253,10 @@ def handle_key(self, key_event: KeyEvent) -> bool: if k == "down": self._scroll_offset += 3 return True + if k == "[" or (k == "tab" and key_event.shift): + return self._select_relative_diagram_view(-1) + if k in {"]", "tab"}: + return self._select_relative_diagram_view(1) if len(k) == 1 and k.isdigit() and k != "0": idx = int(k) - 1 if 0 <= idx < len(self._tabs): @@ -255,17 +292,19 @@ def render(self) -> RenderableType: rule = Rule(style="dim") content = self._render_content() hint = self._render_hint() - viewport = self._apply_viewport(content) warning = self._render_completeness_warning() if self._selecting else None - parts: list[RenderableType] = [tab_bar, rule, viewport, Text()] + prefix_parts: list[RenderableType] = [tab_bar, rule] + suffix_parts: list[RenderableType] = [Text()] if warning is not None: - parts.append(warning) - parts.append(Text()) + suffix_parts.append(warning) + suffix_parts.append(Text()) if self._status_message: - parts.append(Text(self._status_message, style="dim italic")) - parts.append(Text()) - parts.append(hint) - return Group(*parts) + suffix_parts.append(Text(self._status_message, style="dim italic")) + suffix_parts.append(Text()) + suffix_parts.append(hint) + reserved_lines = len(self._render_lines(Group(*prefix_parts, *suffix_parts))) + viewport = self._apply_viewport(content, reserved_lines=reserved_lines) + return Group(*prefix_parts, viewport, *suffix_parts) def missing_display_items(self) -> list[str]: missing: list[str] = [] @@ -289,27 +328,34 @@ def _render_completeness_warning(self) -> Text | None: text.append("；".join(missing), style="yellow") return text - def _apply_viewport(self, content: RenderableType) -> RenderableType: - viewport_height = max(self._console.height - CHROME_LINES, 8) - buf = StringIO() - temp = Console(file=buf, width=self._console.width, force_terminal=True, no_color=False) - temp.print(content, end="") - lines = buf.getvalue().splitlines() + def _apply_viewport(self, content: RenderableType, *, reserved_lines: int) -> RenderableType: + available_height = max(self._console.height - reserved_lines, 1) + lines = self._render_lines(content) total = len(lines) - if total <= viewport_height: + if total <= available_height: self._scroll_offset = 0 return content + indicator_budget = min(SCROLL_INDICATOR_LINES, max(available_height - 1, 0)) + viewport_height = max(available_height - indicator_budget, 1) max_offset = max(total - viewport_height, 0) self._scroll_offset = min(self._scroll_offset, max_offset) visible = lines[self._scroll_offset : self._scroll_offset + viewport_height] + show_scroll_up = self._scroll_offset > 0 and indicator_budget > 0 + show_scroll_down = self._scroll_offset < max_offset and indicator_budget > int(show_scroll_up) parts: list[RenderableType] = [] - if self._scroll_offset > 0: + if show_scroll_up: parts.append(Text(" " + _("Scroll up to view more"), style="dim")) parts.append(Text.from_ansi("\n".join(visible))) - if self._scroll_offset < max_offset: + if show_scroll_down: parts.append(Text(" " + _("Scroll down to view more"), style="dim")) return Group(*parts) + def _render_lines(self, renderable: RenderableType) -> list[str]: + buf = StringIO() + temp = Console(file=buf, width=self._console.width, force_terminal=True, no_color=False) + temp.print(renderable, end="") + return buf.getvalue().splitlines() + def _render_tab_bar(self) -> Text: text = Text() for i, tab in enumerate(self._tabs): @@ -333,8 +379,17 @@ def _render_content(self) -> RenderableType: tab = self._tabs[self._selected] parts: list[RenderableType] = [] - if tab.mermaid_source: + if tab.diagram_views: + if len(tab.diagram_views) > 1: + parts.append(self._render_diagram_view_tab_bar(tab)) + active_view = self._active_diagram_view(tab) + parts.append(self._render_diagram(active_view.mermaid_source)) + if tab.diagram_stage == "draft": + parts.append(Text(_("架构图优化中..."), style="dim italic")) + elif tab.mermaid_source: parts.append(self._render_diagram(tab.mermaid_source)) + if tab.diagram_stage == "draft": + parts.append(Text(_("架构图优化中..."), style="dim italic")) else: parts.append(Text(_("Loading architecture diagram..."), style="dim italic")) @@ -351,12 +406,84 @@ def _render_content(self) -> RenderableType: return Group(*parts) + @staticmethod + def _normalize_diagram_views( + views: list[dict[str, Any]] | None, + fallback_mermaid_source: str, + ) -> list[CandidateDiagramView]: + normalized: list[CandidateDiagramView] = [] + if views: + for index, raw in enumerate(views, start=1): + if not isinstance(raw, dict): + continue + mermaid_source = raw.get("mermaid_source") or raw.get("mermaidSource") + if not isinstance(mermaid_source, str) or not mermaid_source.strip(): + continue + view_id = raw.get("id") + title = raw.get("title") + purpose = raw.get("purpose") + normalized.append( + CandidateDiagramView( + view_id=str(view_id or f"view_{index}"), + title=str(title or view_id or _("Diagram {index}").format(index=index)), + mermaid_source=mermaid_source, + purpose=str(purpose or ""), + ) + ) + if not normalized: + normalized.append( + CandidateDiagramView( + view_id="overview", + title=_("Architecture overview"), + mermaid_source=fallback_mermaid_source, + ) + ) + return normalized + + @staticmethod + def _view_index_by_id(views: list[CandidateDiagramView], view_id: str) -> int: + if view_id: + for index, view in enumerate(views): + if view.view_id == view_id: + return index + return 0 + + def _select_relative_diagram_view(self, delta: int) -> bool: + if not self._tabs: + return False + tab = self._tabs[self._selected] + if len(tab.diagram_views) <= 1: + return False + tab.selected_diagram_view_index = (tab.selected_diagram_view_index + delta) % len(tab.diagram_views) + self._scroll_offset = 0 + return True + + @staticmethod + def _active_diagram_view(tab: CandidateTab) -> CandidateDiagramView: + tab.selected_diagram_view_index = min( + max(tab.selected_diagram_view_index, 0), + max(len(tab.diagram_views) - 1, 0), + ) + return tab.diagram_views[tab.selected_diagram_view_index] + + def _render_diagram_view_tab_bar(self, tab: CandidateTab) -> Text: + text = Text() + for index, view in enumerate(tab.diagram_views): + if index > 0: + text.append(" / ", style="dim") + label = view.title + if index == tab.selected_diagram_view_index: + text.append(f" {label} ", style="bold cyan") + else: + text.append(f" {label} ", style="dim") + return text + def _render_diagram(self, mermaid_source: str) -> RenderableType: try: from importlib import import_module render_rich = import_module("termaid").render_rich - return render_rich(mermaid_source) + return style_attachment_lines(render_rich(mermaid_source)) except ImportError: pass # Silent degrade — termaid optional dependency missing. except Exception as exc: @@ -391,4 +518,6 @@ def _render_hint(self) -> Text: hint.append(_(" | 1-{count} jump directly").format(count=len(self._tabs)), style="dim") else: hint = Text(_("↑ ↓ scroll"), style="dim") + if self._tabs and len(self._tabs[self._selected].diagram_views) > 1: + hint.append(" | Tab/[ ] " + _("switch diagrams"), style="dim") return hint diff --git a/src/iac_code/ui/diagram_rendering.py b/src/iac_code/ui/diagram_rendering.py new file mode 100644 index 00000000..46dce204 --- /dev/null +++ b/src/iac_code/ui/diagram_rendering.py @@ -0,0 +1,57 @@ +"""Helpers for terminal architecture diagram rendering.""" + +from __future__ import annotations + +from typing import Any + +from rich.text import Text + +ATTACHMENT_LINE_STYLE = "dim cyan" + + +def style_attachment_lines(renderable: Any) -> Any: + """Dim attachment rows such as '+ EIP' in termaid terminal output.""" + if not isinstance(renderable, Text): + return renderable + + styled = renderable.copy() + active_attachment_segments: list[tuple[int, int]] = [] + offset = 0 + for line in styled.plain.splitlines(keepends=True): + next_active_segments: list[tuple[int, int]] = [] + for left, right in _vertical_segments(line): + content = line[left + 1 : right] + stripped = content.strip() + if not stripped: + continue + if stripped.startswith("+ "): + content_start = offset + left + 1 + content.index("+") + content_end = offset + left + 1 + len(content.rstrip()) + styled.stylize(ATTACHMENT_LINE_STYLE, content_start, content_end) + next_active_segments.append((left, right)) + continue + if _continues_attachment_segment((left, right), active_attachment_segments): + content_start, content_end = _segment_content_bounds(line, left, right) + if content_start < content_end: + styled.stylize(ATTACHMENT_LINE_STYLE, offset + content_start, offset + content_end) + next_active_segments.append((left, right)) + active_attachment_segments = next_active_segments + offset += len(line) + return styled + + +def _vertical_segments(line: str) -> list[tuple[int, int]]: + columns = [index for index, char in enumerate(line.rstrip("\n")) if char == "│"] + return [(columns[index], columns[index + 1]) for index in range(len(columns) - 1)] + + +def _continues_attachment_segment(segment: tuple[int, int], active_segments: list[tuple[int, int]]) -> bool: + left, right = segment + return any(max(left, active_left) < min(right, active_right) for active_left, active_right in active_segments) + + +def _segment_content_bounds(line: str, left: int, right: int) -> tuple[int, int]: + content = line[left + 1 : right] + start = len(content) - len(content.lstrip()) + end = len(content.rstrip()) + return left + 1 + start, left + 1 + end diff --git a/src/iac_code/ui/pipeline_display_replay.py b/src/iac_code/ui/pipeline_display_replay.py index b22e4ca4..de175f4d 100644 --- a/src/iac_code/ui/pipeline_display_replay.py +++ b/src/iac_code/ui/pipeline_display_replay.py @@ -23,6 +23,7 @@ DisplaySubPipeline, DisplaySubStepAttempt, ) +from iac_code.ui.diagram_rendering import style_attachment_lines from iac_code.ui.pipeline_styles import pipeline_step_header, pipeline_title @@ -224,6 +225,8 @@ def _render_candidate_selection_snapshot(self, selection: DisplayCandidateSelect candidate_name, candidate.mermaid_source, candidate_index=candidate.candidate_index, + views=candidate.diagram_views, + diagram_stage=candidate.diagram_stage, ) if candidate.summary or candidate.cost_items or candidate.total_monthly_cost: renderer.add_detail( @@ -291,7 +294,7 @@ def _render_diagram(mermaid_source: str): from importlib import import_module render_rich = import_module("termaid").render_rich - return render_rich(mermaid_source) + return style_attachment_lines(render_rich(mermaid_source)) except Exception: return Markdown(f"```mermaid\n{mermaid_source}\n```") diff --git a/src/iac_code/ui/renderer.py b/src/iac_code/ui/renderer.py index 08b85c0a..5f565e23 100644 --- a/src/iac_code/ui/renderer.py +++ b/src/iac_code/ui/renderer.py @@ -47,6 +47,10 @@ ) from iac_code.tools.cloud.types import translate_status from iac_code.types.stream_events import ( + TOOL_RENDER_DISPLAY_NAME_KEY, + TOOL_RENDER_METADATA_KEY, + TOOL_RENDER_RESULT_COMPACT_KEY, + TOOL_RENDER_RESULT_VERBOSE_KEY, AskUserQuestionEvent, CompactionEvent, DiagramEvent, @@ -72,7 +76,9 @@ ) from iac_code.ui.components.select import OptionType, Select, SelectLayout, TextOption from iac_code.ui.core.key_event import KeyEvent +from iac_code.ui.diagram_rendering import style_attachment_lines from iac_code.ui.spinner import ShimmerSpinner +from iac_code.ui.stream_accumulator import merge_tool_metadata from iac_code.utils.json_utils import extract_partial_string_fields if TYPE_CHECKING: @@ -105,6 +111,22 @@ def _known_tool_result_message( return render_ros_template_tool_result_message(tool_name, output, is_error=is_error, verbose=verbose) +def _tool_render_metadata(rec: "_ToolCallRecord") -> dict[str, Any]: + metadata = rec.metadata if isinstance(rec.metadata, dict) else {} + render_metadata = metadata.get(TOOL_RENDER_METADATA_KEY) + return render_metadata if isinstance(render_metadata, dict) else {} + + +def _tool_render_metadata_text(rec: "_ToolCallRecord", key: str) -> str | None: + value = _tool_render_metadata(rec).get(key) + return value if isinstance(value, str) and value else None + + +def _metadata_tool_result_message(rec: "_ToolCallRecord", *, verbose: bool) -> str | None: + key = TOOL_RENDER_RESULT_VERBOSE_KEY if verbose else TOOL_RENDER_RESULT_COMPACT_KEY + return _tool_render_metadata_text(rec, key) + + def _permission_detail_text(tool_name: str, tool_input: dict[str, Any], tool: Any | None) -> str | None: if tool_name == "aliyun_api": summary = json.dumps(build_input_summary(tool_name, tool_input), ensure_ascii=False, sort_keys=True) @@ -293,6 +315,56 @@ def _queue_current(self) -> bool: return True +def _archive_segments_for_scrollback(segments: list[_Segment]) -> list[_Segment]: + """Create scrollback-safe segment copies. + + Streaming segments may reference runtime-only renderables such as progress + widgets. Some of those objects own locks, so a blind ``deepcopy`` can fail + while finalizing the turn. Scrollback only needs the stable display data; + live render helpers are resolved again from the registry when possible. + """ + + return [_archive_segment_for_scrollback(segment) for segment in segments] + + +def _archive_segment_for_scrollback(segment: _Segment) -> _Segment: + if segment.kind == "tool" and segment.tool is not None: + return _Segment( + kind=segment.kind, + text=segment.text, + tool=_archive_tool_record_for_scrollback(segment.tool), + elapsed_seconds=segment.elapsed_seconds, + ) + return _Segment(kind=segment.kind, text=segment.text, elapsed_seconds=segment.elapsed_seconds) + + +def _archive_tool_record_for_scrollback(record: _ToolCallRecord) -> _ToolCallRecord: + children = None + if record.children is not None: + children = [ + _SubAgentChild( + tool_name=child.tool_name, + tool_input=copy.deepcopy(child.tool_input), + is_done=child.is_done, + is_error=child.is_error, + ) + for child in record.children + ] + + return _ToolCallRecord( + tool_name=record.tool_name, + tool_input=copy.deepcopy(record.tool_input), + partial_input=record.partial_input, + result=record.result, + is_error=record.is_error, + done=record.done, + children=children, + start_time=record.start_time, + progress_renderable=None, + metadata=copy.deepcopy(record.metadata), + ) + + class Renderer: """Bridge between stream events and terminal output.""" @@ -642,7 +714,7 @@ def _render_diagram(self, event: DiagramEvent) -> Group: from importlib import import_module render_rich = import_module("termaid").render_rich - diagram = render_rich(event.mermaid_source) + diagram = style_attachment_lines(render_rich(event.mermaid_source)) return Group(title, Text(""), diagram, Text("")) except ImportError: pass # Silent degrade — termaid optional dependency missing. @@ -663,6 +735,10 @@ def _has_verbose_content(self, rec: _ToolCallRecord) -> bool: if rec.children: return True tool = self._tool_for_record(rec) + compact_metadata = _metadata_tool_result_message(rec, verbose=False) + verbose_metadata = _metadata_tool_result_message(rec, verbose=True) + if verbose_metadata is not None and compact_metadata != verbose_metadata: + return True if tool is None: return False if tool.render_tool_use_message(rec.tool_input, verbose=False) != tool.render_tool_use_message( @@ -679,7 +755,7 @@ def _any_segment_has_verbose(self, segments: list[_Segment]) -> bool: return any(s.kind == "tool" and s.tool and self._has_verbose_content(s.tool) for s in segments) def _tool_for_record(self, rec: _ToolCallRecord): - return rec.renderer_tool or self._tool_registry.get(rec.tool_name) + return self._tool_registry.get(rec.tool_name) def _render_tool_header(self, rec: _ToolCallRecord) -> Text: """Render ``● ToolName(detail)`` line with optional child tool tree.""" @@ -695,7 +771,12 @@ def _render_tool_header(self, rec: _ToolCallRecord) -> Text: effective_input = extract_partial_string_fields(rec.partial_input, set(preview_fields)) raw_tool_name = rec.tool_name - tool_name = _display_tool_name(raw_tool_name, tool.user_facing_name(effective_input) if tool else raw_tool_name) + candidate_name = ( + tool.user_facing_name(effective_input) + if tool + else _tool_render_metadata_text(rec, TOOL_RENDER_DISPLAY_NAME_KEY) + ) + tool_name = _display_tool_name(raw_tool_name, candidate_name) detail = tool.render_tool_use_message(effective_input, verbose=self._verbose) if tool else None line = Text() @@ -784,6 +865,8 @@ def _render_tool_result(self, rec: _ToolCallRecord) -> Text | None: result_text = tool.render_tool_result_message( rec.result or "", is_error=rec.is_error, verbose=self._verbose ) + if result_text is None: + result_text = _metadata_tool_result_message(rec, verbose=self._verbose) if result_text is None and rec.result: result_text = _known_tool_result_message( rec.tool_name, @@ -1244,7 +1327,7 @@ async def _rebuild_after_transcript(): tool_name=event.name, tool_input={}, start_time=time.monotonic(), - renderer_tool=event.renderer_tool, + metadata=event.metadata, ) tool_records[event.tool_use_id] = rec segments.append(_Segment(kind="tool", tool=rec)) @@ -1293,6 +1376,7 @@ async def _rebuild_after_transcript(): rec.result = event.result rec.is_error = event.is_error rec.done = True + rec.metadata = merge_tool_metadata(rec.metadata, event.metadata) spinner = None _ensure_live() _update_live() @@ -1847,7 +1931,7 @@ async def prompt_user_question(self, event: AskUserQuestionEvent) -> dict[str, s def _print_segments_to_scrollback(self, segments: list[_Segment], trailing_text: str) -> None: """Print finalized segments to terminal scrollback.""" - archived = copy.deepcopy(segments) + archived = _archive_segments_for_scrollback(segments) if trailing_text: archived.append(_Segment(kind="text", text=trailing_text)) if not archived: diff --git a/src/iac_code/ui/repl.py b/src/iac_code/ui/repl.py index 4a68ea8c..965f0fef 100644 --- a/src/iac_code/ui/repl.py +++ b/src/iac_code/ui/repl.py @@ -3558,6 +3558,8 @@ async def restored_selection_stream(): candidate_index=candidate.candidate_index, template_content="", mermaid_source=candidate.mermaid_source, + diagram_stage=candidate.diagram_stage, + views=candidate.diagram_views, ) if candidate.summary or candidate.cost_items or candidate.total_monthly_cost: yield CandidateDetailEvent( @@ -4480,6 +4482,8 @@ async def _stop_key_reader() -> None: event.candidate_name, event.mermaid_source, candidate_index=event.candidate_index, + views=event.views, + diagram_stage=event.diagram_stage, ) elif isinstance(event, CandidateDetailEvent): diff --git a/src/iac_code/ui/stream_accumulator.py b/src/iac_code/ui/stream_accumulator.py index 7e65b605..e25241bd 100644 --- a/src/iac_code/ui/stream_accumulator.py +++ b/src/iac_code/ui/stream_accumulator.py @@ -7,6 +7,7 @@ from __future__ import annotations +import copy import time from dataclasses import dataclass from typing import Any @@ -48,7 +49,7 @@ class ToolCallRecord: children: list[SubAgentChild] | None = None start_time: float = 0.0 progress_renderable: Any = None - renderer_tool: Any = None + metadata: dict[str, Any] | None = None @dataclass @@ -62,6 +63,29 @@ class RenderSegment: elapsed_seconds: float = 0.0 +def merge_tool_metadata( + current: dict[str, Any] | None, + update: dict[str, Any] | None, +) -> dict[str, Any] | None: + """Merge tool event metadata while preserving nested internal metadata.""" + + if not current: + return copy.deepcopy(update) if update else None + if not update: + return copy.deepcopy(current) + + merged = copy.deepcopy(current) + for key, value in update.items(): + existing = merged.get(key) + if isinstance(existing, dict) and isinstance(value, dict): + nested = copy.deepcopy(existing) + nested.update(copy.deepcopy(value)) + merged[key] = nested + else: + merged[key] = copy.deepcopy(value) + return merged + + class StreamAccumulator: """Accumulates StreamEvents into renderable segments. @@ -116,7 +140,7 @@ def process(self, event: StreamEvent) -> str: tool_name=event.name, tool_input={}, start_time=time.monotonic(), - renderer_tool=event.renderer_tool, + metadata=event.metadata, ) self.tool_records[event.tool_use_id] = rec self.segments.append(RenderSegment(kind="tool", tool=rec)) @@ -144,6 +168,7 @@ def process(self, event: StreamEvent) -> str: rec.result = event.result rec.is_error = event.is_error rec.done = True + rec.metadata = merge_tool_metadata(rec.metadata, event.metadata) return "tool_done" if isinstance(event, SubAgentToolEvent): diff --git a/src/iac_code/ui/transcript_view.py b/src/iac_code/ui/transcript_view.py index 46fa81c1..fac098cd 100644 --- a/src/iac_code/ui/transcript_view.py +++ b/src/iac_code/ui/transcript_view.py @@ -14,6 +14,7 @@ from rich.text import Text from iac_code.i18n import _ +from iac_code.types.stream_events import TOOL_RENDER_METADATA_KEY, TOOL_RENDER_VERBOSE_RESULT_IN_TRANSCRIPT_KEY from iac_code.ui.core.key_event import KeyEvent from iac_code.ui.core.raw_input import RawInputCapture from iac_code.ui.core.screen import ScreenManager @@ -140,8 +141,7 @@ def _render_tool(self, rec: "_ToolCallRecord") -> None: self._console.print(line) # Most tool results stay compact so we never dump full file contents. - # Pipeline-only tools can carry their real Tool renderer on the record; - # if that renderer has curated verbose output, use it generically. + # Tools that have curated verbose output opt in through render metadata. if self._should_render_result_verbose(rec): saved = r._verbose r._verbose = True @@ -155,10 +155,16 @@ def _render_tool(self, rec: "_ToolCallRecord") -> None: self._console.print(result_line) def _should_render_result_verbose(self, rec: "_ToolCallRecord") -> bool: - renderer_tool = getattr(rec, "renderer_tool", None) - if renderer_tool is None: - return False - if not bool(getattr(renderer_tool, "render_verbose_result_in_transcript", False)): + metadata = getattr(rec, "metadata", None) + render_metadata = metadata.get(TOOL_RENDER_METADATA_KEY) if isinstance(metadata, dict) else None + if isinstance(render_metadata, dict) and bool( + render_metadata.get(TOOL_RENDER_VERBOSE_RESULT_IN_TRANSCRIPT_KEY) + ): + return bool(self._renderer._has_verbose_content(rec)) + + tool_for_record = getattr(self._renderer, "_tool_for_record", None) + tool = tool_for_record(rec) if callable(tool_for_record) else None + if not bool(getattr(tool, "render_verbose_result_in_transcript", False)): return False return bool(self._renderer._has_verbose_content(rec)) diff --git a/tests/a2a/test_pipeline_events.py b/tests/a2a/test_pipeline_events.py index 64cdf871..f6f990f5 100644 --- a/tests/a2a/test_pipeline_events.py +++ b/tests/a2a/test_pipeline_events.py @@ -1032,6 +1032,12 @@ def test_candidate_detail_and_diagram_have_distinct_event_types() -> None: template_content="ROSTemplateFormatVersion: '2015-09-01'", mermaid_source="graph TD", candidate_index=0, + architecture_context={"visible_nodes": [{"id": "ECS"}]}, + diagram_stage="optimized", + views=[ + {"id": "overview", "title": "Overview", "mermaid_source": "graph TD"}, + {"id": "detail_app", "title": "App", "mermaid_source": "graph TD; A-->B"}, + ], ), ) )[0] @@ -1049,6 +1055,9 @@ def test_candidate_detail_and_diagram_have_distinct_event_types() -> None: assert diagram["eventType"] == "diagram_shown" assert diagram["data"]["format"] == "mermaid" assert diagram["data"]["candidateIndex"] == 0 + assert diagram["data"]["architectureContext"] == {"visible_nodes": [{"id": "ECS"}]} + assert diagram["data"]["diagramStage"] == "optimized" + assert [view["id"] for view in diagram["data"]["views"]] == ["overview", "detail_app"] def test_top_level_candidate_detail_is_attached_to_current_step() -> None: diff --git a/tests/agent/test_agent_loop_new.py b/tests/agent/test_agent_loop_new.py index 7ff0596a..4b6080c9 100644 --- a/tests/agent/test_agent_loop_new.py +++ b/tests/agent/test_agent_loop_new.py @@ -11,6 +11,9 @@ from iac_code.tools.tool_executor import ToolExecutor from iac_code.types.permissions import PermissionResult from iac_code.types.stream_events import ( + TOOL_RENDER_DISPLAY_NAME_KEY, + TOOL_RENDER_METADATA_KEY, + TOOL_RENDER_RESULT_COMPACT_KEY, CompactionEvent, MessageEndEvent, MessageStartEvent, @@ -1802,7 +1805,7 @@ async def fake_stream(messages, system, tools=None, max_tokens=8192): assert tool_blocks[0].content == "preview result" assert tool_blocks[0].metadata == {"_iac_code_externalized_result_path": str(stored_result)} - async def test_tool_use_start_event_carries_renderer_tool(self, mock_provider, mock_registry): + async def test_tool_events_carry_render_metadata_not_renderer_tool(self, mock_provider, mock_registry): call_count = 0 async def fake_stream(messages, system, tools=None, max_tokens=8192): @@ -1823,6 +1826,7 @@ async def fake_stream(messages, system, tools=None, max_tokens=8192): input_schema={}, needs_event_queue=lambda: False, check_permissions=AsyncMock(return_value=PermissionResult(behavior="allow")), + user_facing_name=lambda input=None: "Rendered tool", render_tool_result_message=lambda output, *, is_error=False, verbose=False: ( "verbose result" if verbose else "compact result" ), @@ -1843,10 +1847,19 @@ async def fake_stream(messages, system, tools=None, max_tokens=8192): tool_results = [e for e in events if isinstance(e, ToolResultEvent)] assert len(tool_results) == 1 - assert tool_results[0].metadata is None + assert tool_results[0].metadata == { + TOOL_RENDER_METADATA_KEY: { + TOOL_RENDER_RESULT_COMPACT_KEY: "compact result", + } + } tool_starts = [e for e in events if isinstance(e, ToolUseStartEvent)] assert len(tool_starts) == 1 - assert tool_starts[0].renderer_tool is tool + assert not hasattr(tool_starts[0], "renderer_tool") + assert tool_starts[0].metadata == { + TOOL_RENDER_METADATA_KEY: { + TOOL_RENDER_DISPLAY_NAME_KEY: "Rendered tool", + } + } async def test_terminal_error_step_result_metadata_stops_streaming(self, mock_provider, mock_registry): from iac_code.pipeline.engine.types import StepResult, StepStatus diff --git a/tests/cli/test_output_formats.py b/tests/cli/test_output_formats.py index 426fe655..3b01b113 100644 --- a/tests/cli/test_output_formats.py +++ b/tests/cli/test_output_formats.py @@ -5,7 +5,6 @@ import asyncio import io import json -from types import SimpleNamespace from iac_code.cli.output_formats import ( JsonWriter, @@ -18,6 +17,8 @@ from iac_code.tools.result_storage import EXTERNALIZED_RESULT_PATH_METADATA_KEY, ResultStorage from iac_code.types.permissions import PermissionAuditMetadata, PermissionAuditSettings, PermissionResult from iac_code.types.stream_events import ( + TOOL_RENDER_METADATA_KEY, + TOOL_RENDER_RESULT_COMPACT_KEY, ErrorEvent, MessageEndEvent, MessageStartEvent, @@ -255,14 +256,14 @@ def test_tool_events_emitted(self) -> None: assert second["type"] == "tool_result" assert "signature-secret" not in stream.getvalue() - def test_tool_use_start_omits_renderer_tool(self) -> None: + def test_tool_use_start_omits_internal_render_metadata(self) -> None: stream = io.StringIO() writer = StreamJsonWriter(stream) writer.handle( ToolUseStartEvent( tool_use_id="tu_1", name="infraguard_scan", - renderer_tool=SimpleNamespace(name="infraguard_scan"), + metadata={TOOL_RENDER_METADATA_KEY: {"display_name": "InfraGuard scan"}}, ) ) @@ -488,6 +489,45 @@ def test_tool_result_omits_internal_externalized_result_path_metadata(self) -> N assert "/Users/alice" not in rendered assert data["metadata"] == {"step_result": {"step_id": "x"}} + def test_tool_result_omits_internal_render_metadata(self) -> None: + stream = io.StringIO() + writer = StreamJsonWriter(stream) + writer.handle( + ToolResultEvent( + tool_use_id="tu_1", + tool_name="infraguard_scan", + result="preview", + metadata={ + TOOL_RENDER_METADATA_KEY: {TOOL_RENDER_RESULT_COMPACT_KEY: "passed · 0 findings"}, + "step_result": {"step_id": "x"}, + }, + ) + ) + + data = json.loads(stream.getvalue()) + rendered = json.dumps(data, ensure_ascii=False) + assert TOOL_RENDER_METADATA_KEY not in rendered + assert "passed · 0 findings" not in rendered + assert data["metadata"] == {"step_result": {"step_id": "x"}} + + def test_tool_result_omits_metadata_when_only_internal_render_metadata_remains(self) -> None: + stream = io.StringIO() + writer = StreamJsonWriter(stream) + writer.handle( + ToolResultEvent( + tool_use_id="tu_1", + tool_name="infraguard_scan", + result="preview", + metadata={TOOL_RENDER_METADATA_KEY: {TOOL_RENDER_RESULT_COMPACT_KEY: "passed · 0 findings"}}, + ) + ) + + data = json.loads(stream.getvalue()) + rendered = json.dumps(data, ensure_ascii=False) + assert TOOL_RENDER_METADATA_KEY not in rendered + assert "passed · 0 findings" not in rendered + assert "metadata" not in data + def test_failed_tool_result_redacts_encoded_malformed_artifact_uri(self) -> None: stream = io.StringIO() writer = StreamJsonWriter(stream) diff --git a/tests/pipeline/engine/test_architecture_graph.py b/tests/pipeline/engine/test_architecture_graph.py new file mode 100644 index 00000000..a2fb9525 --- /dev/null +++ b/tests/pipeline/engine/test_architecture_graph.py @@ -0,0 +1,3860 @@ +from iac_code.pipeline.engine.architecture_graph import ( + render_ros_template_architecture, + render_ros_template_architecture_views, +) +from iac_code.pipeline.engine.show_diagram_tool import ros_template_to_mermaid + + +def _set_test_language(monkeypatch, language: str) -> None: + from iac_code.i18n import setup_i18n + + monkeypatch.setenv("LANGUAGE", language) + monkeypatch.setenv("LC_ALL", "{}_CN.UTF-8".format(language) if language == "zh" else "en_US.UTF-8") + monkeypatch.setenv("LANG", "{}_CN.UTF-8".format(language) if language == "zh" else "en_US.UTF-8") + setup_i18n() + + +def _filler_resources(count: int = 24) -> str: + return "".join( + f"""\ + Bucket{index}: + Type: ALIYUN::OSS::Bucket +""" + for index in range(1, count + 1) + ) + + +def test_uses_meta_resource_name_for_storage_resource(): + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + Bucket: + Type: ALIYUN::OSS::Bucket + Properties: + BucketName: demo-bucket +""" + + mermaid = ros_template_to_mermaid(template) + + assert 'Bucket["OSS Bucket"]' in mermaid + + +def test_architecture_context_includes_template_description(monkeypatch): + _set_test_language(monkeypatch, "zh") + try: + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Description: + zh-cn: 在现有VPC下，创建Kafka集群，包含管理节点与弹性伸缩节点。 + en: Deploy a Kafka cluster in an existing VPC. +Resources: + Master: + Type: ALIYUN::ECS::InstanceGroup + Workers: + Type: ALIYUN::ESS::ScalingGroup +""" + + context = render_ros_template_architecture(template).architecture_context + + assert context["template_summary"]["description"] == "在现有VPC下，创建Kafka集群，包含管理节点与弹性伸缩节点。" + assert context["template_summary"]["descriptions"]["en"] == "Deploy a Kafka cluster in an existing VPC." + finally: + _set_test_language(monkeypatch, "en") + + +def test_uses_current_language_for_resource_and_layer_labels(monkeypatch): + _set_test_language(monkeypatch, "zh") + try: + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + VPC: + Type: ALIYUN::ECS::VPC + VSwitch: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: VPC + ECS: + Type: ALIYUN::ECS::Instance + Properties: + VSwitchId: + Ref: VSwitch + InstanceName: windows_vCenter + Redis: + Type: ALIYUN::REDIS::Instance + Properties: + VSwitchId: + Ref: VSwitch +""" + + mermaid = ros_template_to_mermaid(template) + + assert "subgraph layer_VPC [专有网络 VPC]" in mermaid + assert "subgraph layer_VSwitch [交换机]" in mermaid + assert 'ECS["ECS 实例"]' in mermaid + assert 'Redis["Redis实例"]' in mermaid + finally: + _set_test_language(monkeypatch, "en") + + +def test_uses_meta_relation_to_place_nas_inside_vswitch(): + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + VPC: + Type: ALIYUN::ECS::VPC + VSwitch: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: VPC + NAS: + Type: ALIYUN::NAS::FileSystem + Properties: + VSwitchId: + Ref: VSwitch +""" + + mermaid = ros_template_to_mermaid(template) + + assert 'NAS["NAS File System"]' in mermaid + assert mermaid.index("layer_VSwitch") < mermaid.index('NAS["NAS File System"]') + + +def test_declared_workspace_container_places_pai_resources_inside_workspace(): + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + Workspace: + Type: ALIYUN::PAI::Workspace + Dataset: + Type: ALIYUN::PAI::Dataset + Properties: + WorkspaceId: + Ref: Workspace +""" + + mermaid = ros_template_to_mermaid(template) + + assert "subgraph layer_Workspace [PAI Workspace]" in mermaid + assert 'Dataset["PAI Dataset"]' in mermaid + assert mermaid.index("layer_Workspace") < mermaid.index('Dataset["PAI Dataset"]') + + +def test_cen_instance_contains_transit_router_instead_of_drawing_long_dependency_edge(): + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + CEN: + Type: ALIYUN::CEN::CenInstance + TransitRouter: + Type: ALIYUN::CEN::TransitRouter + Properties: + CenId: + Ref: CEN +""" + + mermaid = ros_template_to_mermaid(template) + + assert "subgraph layer_CEN [CEN Instance]" in mermaid + assert 'TransitRouter["CEN Transit Router"]' in mermaid + assert mermaid.index("subgraph layer_CEN") < mermaid.index('TransitRouter["CEN Transit Router"]') + assert "CEN -.- TransitRouter" not in mermaid + assert "TransitRouter -.- CEN" not in mermaid + + +def test_subgraph_title_uses_termaid_compatible_label_syntax(): + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + VPC: + Type: ALIYUN::ECS::VPC + Properties: + CidrBlock: 172.16.0.0/12 + VSwitch: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: VPC + CidrBlock: 172.16.0.0/24 +""" + + mermaid = ros_template_to_mermaid(template) + + assert "subgraph layer_VSwitch [VSwitch (172.16.0.0/24)]" in mermaid + assert 'subgraph layer_VSwitch["VSwitch (172.16.0.0/24)"]' not in mermaid + + +def test_folds_meta_main_resource_attachment_into_edge(): + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + ECS: + Type: ALIYUN::ECS::Instance + DataDisk: + Type: ALIYUN::ECS::Disk + DiskAttach: + Type: ALIYUN::ECS::DiskAttachment + Properties: + DiskId: + Ref: DataDisk + InstanceId: + Ref: ECS +""" + + mermaid = ros_template_to_mermaid(template) + + assert "DiskAttach" not in mermaid + assert "DataDisk --> ECS" in mermaid + + +def test_direct_meta_relations_use_dotted_open_edge(): + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + ECS: + Type: ALIYUN::ECS::Instance + ScalingGroup: + Type: ALIYUN::ESS::ScalingGroup + ScalingConfig: + Type: ALIYUN::ESS::ScalingConfiguration + Properties: + InstanceId: + Ref: ECS + ScalingGroupId: + Ref: ScalingGroup +""" + + mermaid = ros_template_to_mermaid(template) + + assert "ECS -.- ScalingConfig" in mermaid + assert "ScalingGroup -.- ScalingConfig" in mermaid + assert "ECS --> ScalingConfig" not in mermaid + assert "ScalingGroup --> ScalingConfig" not in mermaid + + +def test_semantic_plan_adds_valid_llm_inferred_edges_only(): + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + VSwitch: + Type: ALIYUN::ECS::VSwitch + SLB: + Type: ALIYUN::SLB::LoadBalancer + Properties: + VSwitchId: + Ref: VSwitch + ECS: + Type: ALIYUN::ECS::Instance + Properties: + VSwitchId: + Ref: VSwitch +""" + + result = render_ros_template_architecture( + template, + semantic_plan={ + "edges": [ + { + "from": "SLB", + "to": "ECS", + "kind": "traffic", + "label": "forwards traffic", + "confidence": "medium", + }, + { + "from": "SLB", + "to": "MissingNode", + "kind": "traffic", + "label": "invalid", + "confidence": "high", + }, + ] + }, + ) + + assert "SLB -->|forwards traffic| ECS" in result.mermaid_source + assert "MissingNode" not in result.mermaid_source + assert result.architecture_context["semantic_plan"]["accepted_edges"] == [ + { + "from": "SLB", + "to": "ECS", + "kind": "traffic", + "label": "forwards traffic", + "confidence": "medium", + } + ] + assert result.architecture_context["semantic_plan"]["rejected_edges"] == [ + { + "from": "SLB", + "to": "MissingNode", + "reason": "unknown node", + } + ] + + +def test_polardb_migration_from_rds_uses_source_to_target_direction(monkeypatch): + _set_test_language(monkeypatch, "zh") + try: + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + Database: + Type: ALIYUN::RDS::DBInstance + DBCluster: + Type: ALIYUN::POLARDB::DBCluster + Properties: + CreationOption: MigrationFromRDS + SourceResourceId: + Ref: Database +""" + + result = render_ros_template_architecture( + template, + semantic_plan={ + "edges": [ + { + "from": "DBCluster", + "to": "Database", + "kind": "dependency", + "label": "数据迁移源", + "confidence": "high", + } + ] + }, + ) + + assert "Database -->|迁移到| DBCluster" in result.mermaid_source + assert "DBCluster -->|数据迁移源| Database" not in result.mermaid_source + assert { + "from": "Database", + "to": "DBCluster", + "style": "solid_arrow", + "label": "迁移到", + } in result.architecture_context["visible_edges"] + assert result.architecture_context["semantic_plan"]["rejected_edges"] == [ + { + "from": "DBCluster", + "to": "Database", + "reason": "covered by deterministic edge", + } + ] + finally: + _set_test_language(monkeypatch, "en") + + +def test_architecture_view_keeps_deterministic_polardb_migration_edge(monkeypatch): + _set_test_language(monkeypatch, "zh") + try: + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + Database: + Type: ALIYUN::RDS::DBInstance + DBCluster: + Type: ALIYUN::POLARDB::DBCluster + Properties: + CreationOption: MigrationFromRDS + SourceResourceId: + Ref: Database + EcsInstance: + Type: ALIYUN::ECS::Instance +""" + + result = render_ros_template_architecture_views( + template, + semantic_plan={ + "edges": [ + { + "from": "EcsInstance", + "to": "DBCluster", + "kind": "traffic", + "label": "数据库访问", + "confidence": "medium", + } + ], + "views": [ + { + "id": "overview", + "title": "RDS 至 PolarDB 迁移架构", + "purpose": "展示从 RDS 迁移到 PolarDB 的核心组件及业务访问关系", + "layout": "flat", + "nodes": ["Database", "DBCluster", "EcsInstance"], + "edges": [ + { + "from": "EcsInstance", + "to": "DBCluster", + "kind": "traffic", + "label": "数据库访问", + } + ], + } + ], + }, + ) + + assert "Database -->|迁移到| DBCluster" in result.views[0].mermaid_source + assert { + "from": "Database", + "to": "DBCluster", + "style": "solid_arrow", + "label": "迁移到", + } in result.views[0].architecture_context["edges"] + finally: + _set_test_language(monkeypatch, "en") + + +def test_architecture_view_keeps_view_specific_semantic_edge_label(): + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + SLB: + Type: ALIYUN::SLB::LoadBalancer + ECS: + Type: ALIYUN::ECS::Instance +""" + + result = render_ros_template_architecture_views( + template, + semantic_plan={ + "edges": [ + { + "from": "SLB", + "to": "ECS", + "kind": "traffic", + "label": "business traffic", + "confidence": "high", + } + ], + "views": [ + { + "id": "detail_app", + "title": "Application detail", + "purpose": "Show request forwarding.", + "layout": "flat", + "nodes": ["SLB", "ECS"], + "edges": [ + { + "from": "SLB", + "to": "ECS", + "kind": "traffic", + "label": "HTTP forwarding", + } + ], + } + ], + }, + ) + + assert "SLB -->|HTTP forwarding| ECS" in result.views[0].mermaid_source + assert "SLB -->|business traffic| ECS" not in result.views[0].mermaid_source + + +def test_render_architecture_views_filters_each_mermaid_view(): + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + VPC: + Type: ALIYUN::ECS::VPC + VSwitch: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: VPC + ALB: + Type: ALIYUN::ALB::LoadBalancer + Properties: + VpcId: + Ref: VPC + ECS: + Type: ALIYUN::ECS::Instance + Properties: + VSwitchId: + Ref: VSwitch + RDS: + Type: ALIYUN::RDS::DBInstance + Properties: + VSwitchId: + Ref: VSwitch +""" + + result = render_ros_template_architecture_views( + template, + semantic_plan={ + "edges": [ + {"from": "ALB", "to": "ECS", "kind": "traffic", "label": "流量分发"}, + {"from": "ECS", "to": "RDS", "kind": "traffic", "label": "数据库访问"}, + ], + "views": [ + { + "id": "traffic", + "title": "业务流量", + "purpose": "入口到应用", + "nodes": ["ALB", "ECS"], + "edges": [{"from": "ALB", "to": "ECS", "kind": "traffic", "label": "流量分发"}], + }, + { + "id": "data", + "title": "数据访问", + "purpose": "应用访问数据库", + "nodes": ["ECS", "RDS"], + "edges": [{"from": "ECS", "to": "RDS", "kind": "traffic", "label": "数据库访问"}], + }, + ], + }, + ) + + assert [view.id for view in result.views] == ["traffic", "data"] + traffic = result.views[0].mermaid_source + data = result.views[1].mermaid_source + assert 'ALB["ALB Instance"]' in traffic + assert 'ECS["ECS instance"]' in traffic + assert "ALB -->|流量分发| ECS" in traffic + assert "subgraph layer_VPC" not in traffic + assert "subgraph layer_VSwitch" not in traffic + assert "RDS" not in traffic + assert 'RDS["ApsaraDB RDS Instance"]' in data + assert "ECS -->|数据库访问| RDS" in data + assert "ALB" not in data + assert result.views[0].architecture_context["layout"] == "flat" + + +def test_render_architecture_overview_marks_detail_view_anchors(): + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + ALB: + Type: ALIYUN::ALB::LoadBalancer + ECS: + Type: ALIYUN::ECS::Instance + RDS: + Type: ALIYUN::RDS::DBInstance +""" + + result = render_ros_template_architecture_views( + template, + semantic_plan={ + "edges": [ + {"from": "ALB", "to": "ECS", "kind": "traffic", "label": "流量分发"}, + {"from": "ECS", "to": "RDS", "kind": "traffic", "label": "数据库访问"}, + ], + "views": [ + { + "id": "overview", + "title": "架构总览", + "purpose": "整体链路", + "nodes": ["ALB", "ECS", "RDS"], + "edges": [ + {"from": "ALB", "to": "ECS", "kind": "traffic", "label": "流量分发"}, + {"from": "ECS", "to": "RDS", "kind": "traffic", "label": "数据库访问"}, + ], + }, + { + "id": "detail_app", + "title": "应用层展开", + "purpose": "展开应用层", + "anchors": ["ECS"], + "nodes": ["ALB", "ECS"], + "edges": [{"from": "ALB", "to": "ECS", "kind": "traffic", "label": "流量分发"}], + }, + ], + }, + ) + + overview = result.views[0].mermaid_source + detail = result.views[1] + assert 'ECS["ECS instance' in overview + assert "展开: 应用层展开" in overview + assert "\\n展开: 应用层展开" in overview + assert 'ALB["ALB Instance' in overview + assert 'ALB["ALB Instance\n展开: 应用层展开"]' not in overview + assert detail.architecture_context["anchors"] == ["ECS"] + + +def test_render_architecture_overview_supports_semantic_summary_groups(): + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + VPC: + Type: ALIYUN::ECS::VPC + VSwitch: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: VPC + ECS1: + Type: ALIYUN::ECS::Instance + Properties: + VSwitchId: + Ref: VSwitch + ECS2: + Type: ALIYUN::ECS::Instance + Properties: + VSwitchId: + Ref: VSwitch + Redis: + Type: ALIYUN::REDIS::Instance + Properties: + VSwitchId: + Ref: VSwitch +""" + + result = render_ros_template_architecture_views( + template, + semantic_plan={ + "node_labels": [ + {"id": "ECS1", "label": "应用服务器 1", "confidence": "high", "reason": "test"}, + {"id": "ECS2", "label": "应用服务器 2", "confidence": "high", "reason": "test"}, + {"id": "Redis", "label": "Redis 缓存", "confidence": "high", "reason": "test"}, + ], + "views": [ + { + "id": "overview", + "title": "总览", + "purpose": "概览", + "layout": "contained", + "groups": [{"id": "AppGroup", "label": "应用服务器组", "members": ["ECS1", "ECS2"]}], + "nodes": ["AppGroup", "Redis"], + "edges": [{"from": "AppGroup", "to": "Redis", "kind": "traffic", "label": "缓存访问"}], + }, + { + "id": "detail_app", + "title": "应用层详情", + "purpose": "展开应用层", + "anchors": ["AppGroup"], + "nodes": ["ECS1", "ECS2"], + "edges": [{"from": "ECS1", "to": "ECS2", "kind": "management", "label": "同组部署"}], + }, + ], + }, + ) + + overview = result.views[0].mermaid_source + assert "subgraph layer_VPC" in overview + assert "subgraph layer_VSwitch" in overview + assert 'AppGroup["应用服务器组\\n+ 应用服务器 1\\n+ 应用服务器 2\\n展开: 应用层详情"]' in overview + assert 'Redis["Redis 缓存"]' in overview + assert "AppGroup -->|缓存访问| Redis" in overview + assert 'ECS1["应用服务器 1"]' not in overview + assert 'ECS2["应用服务器 2"]' not in overview + assert result.views[1].architecture_context["anchors"] == ["AppGroup"] + + +def test_render_architecture_overview_collapses_many_vswitch_boundaries(monkeypatch): + _set_test_language(monkeypatch, "zh") + try: + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + Vpc: + Type: ALIYUN::ECS::VPC + VSwitch1: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: Vpc + VSwitch2: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: Vpc + VSwitch3: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: Vpc + Alb: + Type: ALIYUN::ALB::LoadBalancer + Properties: + VpcId: + Ref: Vpc + ZoneMappings: + - VSwitchId: + Ref: VSwitch1 + App1: + Type: ALIYUN::ECS::InstanceGroup + Properties: + VSwitchId: + Ref: VSwitch2 + App2: + Type: ALIYUN::ECS::InstanceGroup + Properties: + VSwitchId: + Ref: VSwitch3 + Rds: + Type: ALIYUN::RDS::DBInstance + Properties: + VSwitchId: + Ref: VSwitch3 + Nat: + Type: ALIYUN::VPC::NatGateway + Properties: + VpcId: + Ref: Vpc + VSwitchId: + Ref: VSwitch3 +""" + + result = render_ros_template_architecture_views( + template, + semantic_plan={ + "node_labels": [ + {"id": "Alb", "label": "应用入口 ALB", "confidence": "high"}, + {"id": "App1", "label": "应用服务器组 1", "confidence": "high"}, + {"id": "App2", "label": "应用服务器组 2", "confidence": "high"}, + {"id": "Rds", "label": "RDS 数据库", "confidence": "high"}, + {"id": "Nat", "label": "NAT 网关", "confidence": "high"}, + ], + "views": [ + { + "id": "overview", + "title": "总览", + "layout": "contained", + "nodes": ["Alb", "App1", "App2", "Rds", "Nat"], + "edges": [ + {"from": "Alb", "to": "App1", "kind": "traffic", "label": "后端转发"}, + {"from": "Alb", "to": "App2", "kind": "traffic", "label": "后端转发"}, + {"from": "App1", "to": "Rds", "kind": "dependency", "label": "数据库访问"}, + {"from": "App2", "to": "Rds", "kind": "dependency", "label": "数据库访问"}, + {"from": "App1", "to": "Nat", "kind": "traffic", "label": "SNAT 出网"}, + {"from": "App2", "to": "Nat", "kind": "traffic", "label": "SNAT 出网"}, + ], + } + ], + }, + ) + + overview = result.views[0].mermaid_source + assert "subgraph layer_Vpc" in overview + assert "subgraph layer_VSwitch" not in overview + assert 'Alb["应用入口 ALB' in overview + assert 'App1["应用服务器组 1' in overview + assert 'Rds["RDS 数据库' in overview + assert "Alb -->|后端转发| App1" in overview + finally: + _set_test_language(monkeypatch, "en") + + +def test_render_architecture_summary_group_marks_cross_container_members(monkeypatch): + _set_test_language(monkeypatch, "zh") + try: + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + VPC1: + Type: ALIYUN::ECS::VPC + VPC2: + Type: ALIYUN::ECS::VPC + VSwitch1: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: VPC1 + VSwitch2: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: VPC2 + ALB1: + Type: ALIYUN::ALB::LoadBalancer + Properties: + VpcId: + Ref: VPC1 + AddressType: Internet + ALB2: + Type: ALIYUN::ALB::LoadBalancer + Properties: + VpcId: + Ref: VPC2 + AddressType: Internet +""" + + result = render_ros_template_architecture_views( + template, + semantic_plan={ + "node_labels": [ + {"id": "ALB1", "label": "生产 ALB 1", "confidence": "high", "reason": "test"}, + {"id": "ALB2", "label": "生产 ALB 2", "confidence": "high", "reason": "test"}, + ], + "views": [ + { + "id": "overview", + "title": "总览", + "purpose": "概览", + "groups": [{"id": "AlbGroup", "label": "生产 ALB", "members": ["ALB1", "ALB2"]}], + "nodes": ["AlbGroup"], + "edges": [], + } + ], + }, + ) + + overview = result.views[0].mermaid_source + assert 'AlbGroup["生产 ALB\\n+ 生产 ALB 1\\n+ 生产 ALB 2\\n+ 跨 VPC x2"]' in overview + finally: + _set_test_language(monkeypatch, "en") + + +def test_render_architecture_network_view_is_flat_by_default(): + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + VPC: + Type: ALIYUN::ECS::VPC + VSwitch: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: VPC + ECS: + Type: ALIYUN::ECS::Instance + Properties: + VSwitchId: + Ref: VSwitch +""" + + result = render_ros_template_architecture_views( + template, + semantic_plan={ + "views": [ + { + "id": "network", + "title": "网络位置", + "purpose": "资源所在网络", + "nodes": ["ECS"], + "edges": [], + } + ] + }, + ) + + network = result.views[0].mermaid_source + assert "subgraph layer_VPC" not in network + assert "subgraph layer_VSwitch" not in network + assert 'ECS["ECS instance"]' in network + assert result.views[0].architecture_context["layout"] == "flat" + + +def test_render_architecture_view_can_explicitly_keep_containment(): + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + VPC: + Type: ALIYUN::ECS::VPC + VSwitch: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: VPC + ECS: + Type: ALIYUN::ECS::Instance + Properties: + VSwitchId: + Ref: VSwitch +""" + + result = render_ros_template_architecture_views( + template, + semantic_plan={ + "views": [ + { + "id": "placement", + "title": "部署位置", + "purpose": "资源所在网络", + "layout": "contained", + "nodes": ["ECS"], + "edges": [], + } + ] + }, + ) + + placement = result.views[0].mermaid_source + assert "subgraph layer_VPC" in placement + assert "subgraph layer_VSwitch" in placement + assert 'ECS["ECS instance"]' in placement + assert result.views[0].architecture_context["layout"] == "contained" + + +def test_render_architecture_views_falls_back_to_overview_without_view_plan(): + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + ECS: + Type: ALIYUN::ECS::Instance +""" + + single = render_ros_template_architecture(template) + views = render_ros_template_architecture_views(template) + + assert len(views.views) == 1 + assert views.views[0].id == "overview" + assert views.views[0].mermaid_source == single.mermaid_source + + +def test_render_architecture_view_uses_edge_endpoints_when_nodes_are_omitted(): + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + ALB: + Type: ALIYUN::ALB::LoadBalancer + ECS: + Type: ALIYUN::ECS::Instance +""" + + result = render_ros_template_architecture_views( + template, + semantic_plan={ + "views": [ + { + "id": "traffic", + "title": "业务流量", + "purpose": "入口到应用", + "nodes": [], + "edges": [{"from": "ALB", "to": "ECS", "kind": "traffic", "label": "流量分发"}], + } + ] + }, + ) + + traffic = result.views[0].mermaid_source + assert 'ALB["ALB Instance"]' in traffic + assert 'ECS["ECS instance"]' in traffic + assert "ALB -->|流量分发| ECS" in traffic + + +def test_semantic_fanout_edges_are_preserved_as_relationships(): + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + NLB: + Type: ALIYUN::NLB::LoadBalancer + ALB1: + Type: ALIYUN::ALB::LoadBalancer + ALB2: + Type: ALIYUN::ALB::LoadBalancer +""" + + result = render_ros_template_architecture( + template, + semantic_plan={ + "edges": [ + { + "from": "NLB", + "to": "ALB1", + "kind": "traffic", + "label": "distribute traffic", + "confidence": "high", + }, + { + "from": "NLB", + "to": "ALB2", + "kind": "traffic", + "label": "distribute traffic", + "confidence": "high", + }, + ] + }, + ) + + assert 'NLB["NLB Instance"]' in result.mermaid_source + assert "NLB -->|distribute traffic| ALB1" in result.mermaid_source + assert "NLB -->|distribute traffic| ALB2" in result.mermaid_source + assert "compacted_edges" not in result.architecture_context["semantic_plan"] + + +def test_semantic_edge_label_collapses_multiline_source_marker_for_terminal_rendering(): + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + ECS: + Type: ALIYUN::ECS::Instance + NAS: + Type: ALIYUN::NAS::FileSystem +""" + + result = render_ros_template_architecture( + template, + semantic_plan={ + "edges": [ + { + "from": "ECS", + "to": "NAS", + "kind": "management", + "label": "挂载 NAS\n云助手", + "confidence": "high", + }, + { + "from": "NAS", + "to": "ECS", + "kind": "management", + "label": "同步数据
    云助手", + "confidence": "high", + }, + ] + }, + ) + + assert "ECS -.->|挂载 NAS（云助手）| NAS" in result.mermaid_source + assert "NAS -.->|同步数据（云助手）| ECS" in result.mermaid_source + + +def test_semantic_plan_renames_visible_node_base_label_only(): + fillers = [] + for index in range(1, 24): + fillers.append( + f"""\ + Bucket{index}: + Type: ALIYUN::OSS::Bucket +""" + ) + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + ECS: + Type: ALIYUN::ECS::Instance + EIP: + Type: ALIYUN::VPC::EIP + EIPAssoc: + Type: ALIYUN::VPC::EIPAssociation + Properties: + AllocationId: + Ref: EIP + InstanceId: + Ref: ECS +""" + "".join(fillers) + + result = render_ros_template_architecture( + template, + semantic_plan={ + "node_labels": [ + { + "id": "ECS", + "label": "vCenter manager", + "confidence": "high", + "reason": "InstanceName=windows_vCenter", + }, + { + "id": "MissingNode", + "label": "ghost", + "confidence": "high", + }, + { + "id": "EIP", + "label": "should not apply", + "confidence": "high", + }, + ] + }, + ) + + assert 'ECS["vCenter manager\\n+ EIP"]' in result.mermaid_source + assert 'ECS["ECS instance\\n+ EIP"]' not in result.mermaid_source + assert { + "id": "ECS", + "label": "vCenter manager\\n+ EIP", + "type": "ALIYUN::ECS::Instance", + } in result.architecture_context["visible_nodes"] + assert result.architecture_context["semantic_plan"]["accepted_node_labels"] == [ + { + "id": "ECS", + "label": "vCenter manager", + "confidence": "high", + "reason": "InstanceName=windows_vCenter", + } + ] + assert result.architecture_context["semantic_plan"]["rejected_node_labels"] == [ + {"id": "MissingNode", "reason": "unknown node"}, + {"id": "EIP", "reason": "unknown node"}, + ] + + +def test_architecture_context_exposes_fact_bundle_for_llm(): + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + VPC: + Type: ALIYUN::ECS::VPC + VSwitch: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: VPC + ECS: + Type: ALIYUN::ECS::Instance + Properties: + VSwitchId: + Ref: VSwitch + InstanceName: windows_vCenter + Redis: + Type: ALIYUN::REDIS::Instance + Properties: + VSwitchId: + Ref: VSwitch +""" + + result = render_ros_template_architecture(template) + context = result.architecture_context + + assert context["version"] == "1.0" + assert {"id": "ECS", "label": "ECS instance", "type": "ALIYUN::ECS::Instance"} in context["visible_nodes"] + assert any(node["id"] == "Redis" and node["type"] == "ALIYUN::REDIS::Instance" for node in context["visible_nodes"]) + assert {"resource": "ECS", "container": "VSwitch"} in context["containment"] + assert context["llm_semantic_plan_schema"]["edges"]["allowed_kinds"] == [ + "traffic", + "dependency", + "management", + "inferred", + ] + assert context["llm_semantic_plan_schema"]["node_labels"]["required_fields"] == [ + "id", + "label", + "confidence", + ] + assert { + "id": "ECS", + "label": "ECS instance", + "type": "ALIYUN::ECS::Instance", + "hints": {"InstanceName": "windows_vCenter"}, + } in context["node_label_hints"] + + +def test_architecture_context_exposes_cen_instance_attachment_facts(): + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Parameters: + OtherVpcId: + Type: String + OtherVbrId: + Type: String + OtherRegion: + Type: String +Resources: + Vpc: + Type: ALIYUN::ECS::VPC + CenInstance: + Type: ALIYUN::CEN::CenInstance + CurrentVpcAttachment: + Type: ALIYUN::CEN::CenInstanceAttachment + Properties: + CenId: + Ref: CenInstance + ChildInstanceType: VPC + ChildInstanceId: + Ref: Vpc + ChildInstanceRegionId: + Ref: ALIYUN::Region + ExternalVpcAttachment: + Type: ALIYUN::CEN::CenInstanceAttachment + Properties: + CenId: + Ref: CenInstance + ChildInstanceType: VPC + ChildInstanceId: + Ref: OtherVpcId + ChildInstanceRegionId: + Ref: OtherRegion + ExternalVbrAttachment: + Type: ALIYUN::CEN::CenInstanceAttachment + Properties: + CenId: + Ref: CenInstance + ChildInstanceType: VBR + ChildInstanceId: + Ref: OtherVbrId + ChildInstanceRegionId: + Ref: OtherRegion +""" + + result = render_ros_template_architecture(template) + + assert { + "id": "CurrentVpcAttachment", + "type": "ALIYUN::CEN::CenInstanceAttachment", + "network": "CEN", + "cen": "CenInstance", + "child_instance_type": "VPC", + "child_instance_id": "Vpc", + "child_instance_region": "Ref:ALIYUN::Region", + "child_resource": "Vpc", + "child_resource_type": "ALIYUN::ECS::VPC", + } in result.architecture_context["network_attachments"] + assert any( + item["id"] == "ExternalVpcAttachment" + and item["child_instance_type"] == "VPC" + and item["child_instance_id"] == "Ref:OtherVpcId" + and item["child_instance_region"] == "Ref:OtherRegion" + for item in result.architecture_context["network_attachments"] + ) + assert any( + item["id"] == "ExternalVbrAttachment" + and item["child_instance_type"] == "VBR" + and item["child_instance_id"] == "Ref:OtherVbrId" + for item in result.architecture_context["network_attachments"] + ) + + +def test_flat_view_renders_container_as_summary_node_without_expanding_children(): + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + Vpc: + Type: ALIYUN::ECS::VPC + Properties: + CidrBlock: 172.16.0.0/12 + VSwitch: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: Vpc + CidrBlock: 172.16.100.0/25 + BackendServer: + Type: ALIYUN::ECS::Instance + Properties: + VpcId: + Ref: Vpc + VSwitchId: + Ref: VSwitch + CenInstance: + Type: ALIYUN::CEN::CenInstance + CenConfig: + Type: ALIYUN::CEN::CenInstanceAttachment + Properties: + CenId: + Ref: CenInstance + ChildInstanceType: VPC + ChildInstanceId: + Ref: Vpc +""" + semantic_plan = { + "views": [ + { + "id": "overview", + "layout": "flat", + "nodes": ["BackendServer"], + "edges": [], + }, + { + "id": "detail_network", + "layout": "flat", + "anchors": ["BackendServer"], + "nodes": ["Vpc", "CenInstance"], + "edges": [{"from": "Vpc", "to": "CenInstance", "kind": "management", "label": "CEN 接入"}], + }, + ] + } + + result = render_ros_template_architecture_views(template, semantic_plan=semantic_plan) + detail = result.views[1].mermaid_source + + assert 'Vpc["VPC (172.16.0.0/12)"]' in detail + assert "subgraph layer_Vpc" not in detail + assert 'BackendServer["ECS instance"]' not in detail + assert "Vpc -.->|CEN 接入| CenInstance" in detail + + +def test_contained_view_summary_group_hides_its_member_nodes(): + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + Vpc: + Type: ALIYUN::ECS::VPC + VSwitch1: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: Vpc + VSwitch2: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: Vpc + BackendServer1: + Type: ALIYUN::ECS::Instance + Properties: + VSwitchId: + Ref: VSwitch1 + BackendServer2: + Type: ALIYUN::ECS::Instance + Properties: + VSwitchId: + Ref: VSwitch2 + LoadBalancer: + Type: ALIYUN::SLB::LoadBalancer +""" + result = render_ros_template_architecture_views( + template, + semantic_plan={ + "views": [ + { + "id": "overview", + "layout": "contained", + "groups": [ + { + "id": "BackendGroup", + "label": "后端服务器组", + "members": ["BackendServer1", "BackendServer2"], + "parent": "Vpc", + } + ], + "nodes": ["Vpc", "LoadBalancer", "BackendGroup"], + "edges": [ + { + "from": "LoadBalancer", + "to": "BackendGroup", + "kind": "traffic", + "label": "流量分发", + } + ], + }, + { + "id": "detail_network", + "title": "网络详情", + "layout": "flat", + "anchors": ["Vpc"], + "nodes": ["Vpc"], + "edges": [], + }, + ], + }, + ) + + overview = result.views[0].mermaid_source + + assert 'BackendGroup["后端服务器组\\n+ ECS instance 1\\n+ ECS instance 2"]' in overview + assert 'BackendServer1["ECS instance"]' not in overview + assert 'BackendServer2["ECS instance"]' not in overview + assert "subgraph layer_VSwitch1" not in overview + assert "subgraph layer_VSwitch2" not in overview + assert "LoadBalancer -->|流量分发| BackendGroup" in overview + assert "\\n展开: 网络详情" not in overview + assert "展开: 网络详情" in overview + + +def test_large_graph_folds_repeated_attachment_markers_into_owner_resource(): + repeated_resources = [] + for index in range(1, 14): + repeated_resources.append( + f"""\ + ENI{index}: + Type: ALIYUN::ECS::NetworkInterface + Properties: + VSwitchId: + Ref: VSwitch + SecurityGroupId: + Ref: SG + AssignPrivateIp{index}: + Type: ALIYUN::ECS::AssignPrivateIpAddresses + Properties: + NetworkInterfaceId: + Ref: ENI{index} + ENIAttachment{index}: + Type: ALIYUN::ECS::NetworkInterfaceAttachment + Properties: + NetworkInterfaceId: + Ref: ENI{index} + InstanceId: + Ref: ECS +""" + ) + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + VPC: + Type: ALIYUN::ECS::VPC + VSwitch: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: VPC + SG: + Type: ALIYUN::ECS::SecurityGroup + ECS: + Type: ALIYUN::ECS::Instance + Properties: + VSwitchId: + Ref: VSwitch + SecurityGroupId: + Ref: SG + EIP1: + Type: ALIYUN::VPC::EIP + EIP2: + Type: ALIYUN::VPC::EIP + EIP3: + Type: ALIYUN::VPC::EIP +""" + "".join(repeated_resources) + + mermaid = ros_template_to_mermaid(template) + + assert 'ECS["ECS instance\\n+ ENI x13\\n+ Security group"]' in mermaid + assert "agg_ECS_NetworkInterface_layer_SG" not in mermaid + assert "agg_VPC_EIP_root" not in mermaid + assert " --> ECS" not in mermaid + assert "Private IP Addresses" not in mermaid + assert "AssignPrivateIp1" not in mermaid + + +def test_small_graph_keeps_individual_repeated_resources(): + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + VPC: + Type: ALIYUN::ECS::VPC + VSwitch: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: VPC + SG: + Type: ALIYUN::ECS::SecurityGroup + ECS: + Type: ALIYUN::ECS::Instance + Properties: + VSwitchId: + Ref: VSwitch + SecurityGroupId: + Ref: SG + ENI1: + Type: ALIYUN::ECS::NetworkInterface + Properties: + VSwitchId: + Ref: VSwitch + SecurityGroupId: + Ref: SG + ENI2: + Type: ALIYUN::ECS::NetworkInterface + Properties: + VSwitchId: + Ref: VSwitch + SecurityGroupId: + Ref: SG +""" + + mermaid = ros_template_to_mermaid(template) + + assert 'ENI1["ENI 1"]' in mermaid + assert 'ENI2["ENI 2"]' in mermaid + assert "ENI x2" not in mermaid + + +def test_large_apsara_template_is_not_compacted(): + resources = [] + for index in range(1, 31): + resources.append( + f"""\ + VSwitch{index}: + Type: APSARA::ECS::VSwitch +""" + ) + template = "ROSTemplateFormatVersion: '2015-09-01'\nResources:\n" + "".join(resources) + + mermaid = ros_template_to_mermaid(template) + + assert 'VSwitch1["ECS::VSwitch 1"]' in mermaid + assert 'VSwitch30["ECS::VSwitch 30"]' in mermaid + assert "agg_ECS_VSwitch_root" not in mermaid + + +def test_scaled_ecs_concept_uses_current_language(monkeypatch): + _set_test_language(monkeypatch, "zh") + try: + fillers = [] + for index in range(1, 25): + fillers.append( + f"""\ + Bucket{index}: + Type: ALIYUN::OSS::Bucket +""" + ) + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + ECS: + Type: ALIYUN::ECS::Instance + ScalingGroup: + Type: ALIYUN::ESS::ScalingGroup + ScalingConfig: + Type: ALIYUN::ESS::ScalingConfiguration + Properties: + InstanceId: + Ref: ECS + ScalingGroupId: + Ref: ScalingGroup +""" + "".join(fillers) + + mermaid = ros_template_to_mermaid(template) + + assert "subgraph layer_ScalingGroupApplicationGroup [应用服务组]" in mermaid + assert 'ScalingGroupScaledEcs["伸缩 ECS 实例"]' in mermaid + assert "ScalingGroup -->|弹性伸缩| ScalingGroupScaledEcs" in mermaid + assert "ECS -.->|伸缩配置| ScalingGroup" in mermaid + assert "ECS -.-|配置来源| ScalingGroupScaledEcs" not in mermaid + finally: + _set_test_language(monkeypatch, "en") + + +def test_medium_graph_uses_terminal_overview_mode_with_scaled_ecs_concept(): + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + VPC: + Type: ALIYUN::ECS::VPC + VSwitch1: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: VPC + VSwitch2: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: VPC + SG: + Type: ALIYUN::ECS::SecurityGroup + ECS: + Type: ALIYUN::ECS::Instance + Properties: + VSwitchId: + Ref: VSwitch2 + SecurityGroupId: + Ref: SG + UserData: + Fn::Join: + - '' + - - Fn::GetAtt: + - Redis + - ConnectionDomain + - Fn::GetAtt: + - PolarDB + - DBClusterId + SLB: + Type: ALIYUN::SLB::LoadBalancer + Properties: + VSwitchId: + Ref: VSwitch1 + EIP1: + Type: ALIYUN::VPC::EIP + EIP2: + Type: ALIYUN::VPC::EIP + EIPAssoc1: + Type: ALIYUN::VPC::EIPAssociation + Properties: + AllocationId: + Ref: EIP1 + InstanceId: + Ref: ECS + EIPAssoc2: + Type: ALIYUN::VPC::EIPAssociation + Properties: + AllocationId: + Ref: EIP2 + InstanceId: + Ref: SLB + DNS: + Type: ALIYUN::DNS::DomainRecord + Image: + Type: ALIYUN::ECS::CustomImage + Properties: + InstanceId: + Ref: ECS + ScalingConfig: + Type: ALIYUN::ESS::ScalingConfiguration + Properties: + InstanceId: + Ref: ECS + ScalingGroupId: + Ref: ScalingGroup + ImageId: + Ref: Image + SecurityGroupId: + Ref: SG + ScalingGroup: + Type: ALIYUN::ESS::ScalingGroup + Properties: + VSwitchId: + Ref: VSwitch1 + ScalingRule: + Type: ALIYUN::ESS::ScalingRule + Properties: + ScalingGroupId: + Ref: ScalingGroup + ScalingEnable: + Type: ALIYUN::ESS::ScalingGroupEnable + Properties: + ScalingGroupId: + Ref: ScalingGroup + ScalingConfigurationId: + Ref: ScalingConfig + InstanceIds: + - Ref: ECS + PolarDB: + Type: ALIYUN::POLARDB::DBCluster + Properties: + VSwitchId: + Ref: VSwitch2 + PolarDBNodes: + Type: ALIYUN::POLARDB::DBNodes + Properties: + DBClusterId: + Ref: PolarDB + PolarDBAccountPrivilege: + Type: ALIYUN::POLARDB::AccountPrivilege + Properties: + DBClusterId: + Ref: PolarDB + PolarDBWhitelist: + Type: ALIYUN::POLARDB::DBClusterAccessWhiteList + Properties: + DBClusterId: + Ref: PolarDB + Redis: + Type: ALIYUN::REDIS::Instance + Properties: + VSwitchId: + Ref: VSwitch1 + RedisWhitelist: + Type: ALIYUN::REDIS::Whitelist + Properties: + InstanceId: + Ref: Redis + WaitConditionHandle: + Type: ALIYUN::ROS::WaitConditionHandle + WaitCondition: + Type: ALIYUN::ROS::WaitCondition + Properties: + Handle: + Ref: WaitConditionHandle +""" + + result = render_ros_template_architecture( + template, + semantic_plan={ + "edges": [ + { + "from": "ScalingGroup", + "to": "Redis", + "kind": "inferred", + "label": "cache", + "confidence": "low", + }, + { + "from": "SLB", + "to": "ScalingGroup", + "kind": "traffic", + "label": "backend", + "confidence": "medium", + }, + { + "from": "ScalingGroup", + "to": "ECS", + "kind": "management", + "label": "Scaling Template", + "confidence": "medium", + }, + { + "from": "ScalingGroup", + "to": "SLB", + "kind": "management", + "label": "associated SLB", + "confidence": "medium", + }, + ] + }, + ) + mermaid = result.mermaid_source + visible_node_lines = [ + line for line in mermaid.splitlines() if '["' in line and not line.strip().startswith("subgraph ") + ] + + assert len(visible_node_lines) <= 10 + assert 'Redis["Redis Instance"]' in mermaid + assert 'PolarDB["PolarDB\\n+ DB node\\n+ Account privilege\\n+ Access whitelist"]' in mermaid + assert 'ECS["ECS instance\\n+ EIP\\n+ Security group"]' in mermaid + assert 'SLB["SLB load balancer\\n+ EIP"]' in mermaid + vswitch1_start = mermaid.index("subgraph layer_VSwitch1") + vswitch2_start = mermaid.index("subgraph layer_VSwitch2") + vswitch1 = mermaid[vswitch1_start : mermaid.index("end", vswitch1_start)] + vswitch2 = mermaid[vswitch2_start : mermaid.index("end", vswitch2_start)] + assert "subgraph layer_ScalingGroupApplicationGroup" not in mermaid + assert 'ECS["ECS instance\\n+ EIP\\n+ Security group"]' in vswitch2 + assert 'ScalingGroupScaledEcs["Scaled ECS instances"]' in vswitch1 + assert 'ScalingGroupScaledEcs["Scaled ECS instances"]' in mermaid + assert "ScalingGroup -->|scales| ScalingGroupScaledEcs" in mermaid + assert "ECS -.->|scaling config| ScalingGroup" in mermaid + assert "ECS -.-|config source| ScalingGroupScaledEcs" not in mermaid + assert "ScalingGroupScaledEcs -.-|cache| Redis" in mermaid + assert "SLB -->|backend| ScalingGroupScaledEcs" in mermaid + assert "ScalingGroup -.->|associated SLB| SLB" not in mermaid + assert "ScalingGroup -.->|ESS Config| ECS" not in mermaid + assert "ScalingGroup -.->|Scaling Template| ECS" not in mermaid + assert "subgraph layer_SG [Security group]" not in mermaid + assert 'ScalingConfig["ESS Config"]' not in mermaid + assert "ECS -.- ScalingConfig" not in mermaid + assert "ScalingGroup -.- ScalingConfig" not in mermaid + assert 'EIP1["EIP"]' not in mermaid + assert 'EIP2["EIP"]' not in mermaid + assert "WaitCondition" not in mermaid + assert "DNS" not in mermaid + assert "Image" not in mermaid + assert "ScalingRule" not in mermaid + assert "ScalingEnable" not in mermaid + assert "PolarDBNodes" not in mermaid + assert "PolarDBAccountPrivilege" not in mermaid + assert "PolarDBWhitelist" not in mermaid + assert "RedisWhitelist" not in mermaid + assert { + "id": "ScalingGroupScaledEcs", + "label": "Scaled ECS instances", + "type": "CONCEPT::ESS::ScaledECS", + } in result.architecture_context["visible_nodes"] + assert result.architecture_context["concept_nodes"] == [ + { + "id": "ScalingGroupScaledEcs", + "label": "Scaled ECS instances", + "type": "CONCEPT::ESS::ScaledECS", + "controller": "ScalingGroup", + "source": "ECS", + "via": "ScalingConfig", + "runtime_source": "ECS", + "group": None, + } + ] + assert result.architecture_context["concept_groups"] == [] + assert { + "source": "ECS", + "target": "Redis", + "property": "UserData", + "source_type": "ALIYUN::ECS::Instance", + "target_type": "ALIYUN::REDIS::Instance", + } in result.architecture_context["property_references"] + assert result.architecture_context["semantic_plan"]["accepted_edges"] == [ + { + "from": "ScalingGroupScaledEcs", + "to": "Redis", + "kind": "inferred", + "label": "cache", + "confidence": "low", + }, + { + "from": "SLB", + "to": "ScalingGroupScaledEcs", + "kind": "traffic", + "label": "backend", + "confidence": "medium", + }, + ] + assert result.architecture_context["semantic_plan"]["rejected_edges"] == [ + { + "from": "ScalingGroup", + "to": "ECS", + "reason": "covered by scaled concept", + }, + { + "from": "ScalingGroup", + "to": "SLB", + "reason": "covered by scaled runtime edge", + }, + ] + + +def test_semantic_plan_rejects_runtime_edges_from_scaled_template_source_when_concept_covers_target(): + fillers = [] + for index in range(1, 24): + fillers.append( + f"""\ + Bucket{index}: + Type: ALIYUN::OSS::Bucket +""" + ) + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + ECS: + Type: ALIYUN::ECS::Instance + ScalingGroup: + Type: ALIYUN::ESS::ScalingGroup + ScalingConfig: + Type: ALIYUN::ESS::ScalingConfiguration + Properties: + InstanceId: + Ref: ECS + ScalingGroupId: + Ref: ScalingGroup + Redis: + Type: ALIYUN::REDIS::Instance +""" + "".join(fillers) + + result = render_ros_template_architecture( + template, + semantic_plan={ + "edges": [ + { + "from": "ScalingGroupScaledEcs", + "to": "Redis", + "kind": "traffic", + "label": "cache access", + "confidence": "high", + }, + { + "from": "ECS", + "to": "Redis", + "kind": "dependency", + "label": "cache config", + "confidence": "medium", + }, + ] + }, + ) + + assert "layer_ScalingGroupApplicationGroup -->|cache access| Redis" in result.mermaid_source + assert "ECS -->|cache config| Redis" not in result.mermaid_source + assert "ScalingGroupScaledEcs -->|cache config| Redis" not in result.mermaid_source + assert result.architecture_context["semantic_plan"]["accepted_edges"] == [ + { + "from": "ScalingGroupApplicationGroup", + "to": "Redis", + "kind": "traffic", + "label": "cache access", + "confidence": "high", + } + ] + assert result.architecture_context["semantic_plan"]["rejected_edges"] == [ + { + "from": "ECS", + "to": "Redis", + "reason": "covered by scaled runtime edge", + } + ] + + +def test_config_heavy_medium_graph_uses_overview_compaction(): + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + VPC: + Type: ALIYUN::ECS::VPC + VSwitch: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: VPC + ECS: + Type: ALIYUN::ECS::Instance + Properties: + VSwitchId: + Ref: VSwitch + Image: + Type: ALIYUN::ECS::CustomImage + Properties: + InstanceId: + Ref: ECS + ScalingGroup: + Type: ALIYUN::ESS::ScalingGroup + ScalingConfig: + Type: ALIYUN::ESS::ScalingConfiguration + Properties: + ImageId: + Ref: Image + ScalingGroupId: + Ref: ScalingGroup + ScalingRule: + Type: ALIYUN::ESS::ScalingRule + Properties: + ScalingGroupId: + Ref: ScalingGroup + ScalingEnable: + Type: ALIYUN::ESS::ScalingGroupEnable + Properties: + ScalingGroupId: + Ref: ScalingGroup + ScalingConfigurationId: + Ref: ScalingConfig + PolarDB: + Type: ALIYUN::POLARDB::DBCluster + PolarDBNode: + Type: ALIYUN::POLARDB::DBInstance + Properties: + DBClusterId: + Ref: PolarDB + PolarDBPrivilege: + Type: ALIYUN::POLARDB::AccountPrivilege + Properties: + DBClusterId: + Ref: PolarDB + PolarDBWhitelist: + Type: ALIYUN::POLARDB::DBClusterAccessWhiteList + Properties: + DBClusterId: + Ref: PolarDB +""" + + result = render_ros_template_architecture( + template, + semantic_plan={ + "edges": [ + { + "from": "AppDeploy", + "to": "Ack", + "kind": "management", + "label": "deploy", + "confidence": "high", + } + ] + }, + ) + mermaid = result.mermaid_source + + assert result.architecture_context["compacted"] is True + assert 'ScalingConfig["ESS Config"]' not in mermaid + assert "ScalingRule" not in mermaid + assert "ScalingEnable" not in mermaid + assert "Image" not in mermaid + assert "PolarDBNode" not in mermaid + assert "PolarDBPrivilege" not in mermaid + assert "PolarDBWhitelist" not in mermaid + assert 'ScalingGroup["ESS Group\\n+ Scaling Configuration\\n+ Scaling Rule"]' in mermaid + assert 'PolarDB["PolarDB\\n+ DB node\\n+ Account privilege\\n+ Access whitelist"]' in mermaid + + +def test_compact_graph_folds_ram_access_keys_and_group_membership_into_user(): + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + User: + Type: ALIYUN::RAM::User + AccessKey: + Type: ALIYUN::RAM::AccessKey + Properties: + UserName: + Ref: User + AccessKey2: + Type: ALIYUN::RAM::AccessKey + Properties: + UserName: + Ref: User + Group: + Type: ALIYUN::RAM::Group + UserGroup: + Type: ALIYUN::RAM::UserToGroupAddition + Properties: + Users: + - Ref: User + GroupName: + Ref: Group + Bucket1: + Type: ALIYUN::OSS::Bucket + Bucket2: + Type: ALIYUN::OSS::Bucket +""" + + result = render_ros_template_architecture( + template, + semantic_plan={ + "edges": [ + { + "from": "AppDeploy", + "to": "Ack", + "kind": "management", + "label": "deploy", + "confidence": "high", + } + ] + }, + ) + mermaid = result.mermaid_source + + assert result.architecture_context["compacted"] is True + assert 'AccessKey["AccessKey"]' not in mermaid + assert 'AccessKey2["AccessKey 2"]' not in mermaid + assert 'UserGroup["RAM UserToGroupAddition"]' not in mermaid + assert 'User["RAM User\\n+ AccessKey x2\\n+ User group"]' in mermaid + assert { + "source": "UserGroup", + "source_type": "ALIYUN::RAM::UserToGroupAddition", + "target": "Group", + "target_type": "ALIYUN::RAM::Group", + "property": "GroupName", + } in result.architecture_context["explicit_relations"] + + +def test_compact_graph_keeps_distinct_middleware_instance_groups(): + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + Vpc: + Type: ALIYUN::ECS::VPC + VSwitch: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: Vpc + SecurityGroup: + Type: ALIYUN::ECS::SecurityGroup + Properties: + VpcId: + Ref: Vpc + AppServer: + Type: ALIYUN::ECS::InstanceGroup + Properties: + InstanceName: AppServer + VpcId: + Ref: Vpc + VSwitchId: + Ref: VSwitch + SecurityGroupId: + Ref: SecurityGroup + MongoDBServer: + Type: ALIYUN::ECS::InstanceGroup + Properties: + InstanceName: MongoDBServer + VpcId: + Ref: Vpc + VSwitchId: + Ref: VSwitch + SecurityGroupId: + Ref: SecurityGroup + RabbitMQServer: + Type: ALIYUN::ECS::InstanceGroup + Properties: + InstanceName: RabbitMQServer + VpcId: + Ref: Vpc + VSwitchId: + Ref: VSwitch + SecurityGroupId: + Ref: SecurityGroup + Role: + Type: ALIYUN::RAM::Role + Bucket: + Type: ALIYUN::OSS::Bucket +""" + + result = render_ros_template_architecture(template) + mermaid = result.mermaid_source + + assert "MongoDBServer" in mermaid + assert "RabbitMQServer" in mermaid + assert "ECS instance group 1 x3" not in mermaid + + +def test_compact_graph_keeps_rds_instance_and_folds_database_children(): + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + VPC: + Type: ALIYUN::ECS::VPC + VSwitch: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: VPC + RdsInstance: + Type: ALIYUN::RDS::DBInstance + Properties: + VSwitchId: + Ref: VSwitch + RdsDatabase: + Type: ALIYUN::RDS::Database + Properties: + DBInstanceId: + Ref: RdsInstance + RdsAccount: + Type: ALIYUN::RDS::Account + Properties: + DBInstanceId: + Ref: RdsInstance + RdsPrivilege: + Type: ALIYUN::RDS::AccountPrivilege + Properties: + DBInstanceId: + Ref: RdsInstance + AccountName: + Ref: RdsAccount + RdsWhitelist: + Type: ALIYUN::RDS::DBInstanceSecurityIps + Properties: + DBInstanceId: + Ref: RdsInstance + ReadOnly1: + Type: ALIYUN::RDS::ReadOnlyDBInstance + Properties: + DBInstanceId: + Ref: RdsInstance + ReadOnly2: + Type: ALIYUN::RDS::ReadOnlyDBInstance + Properties: + DBInstanceId: + Ref: RdsInstance +""" + + result = render_ros_template_architecture(template) + mermaid = result.mermaid_source + + assert result.architecture_context["compacted"] is True + assert "RdsDatabase" not in mermaid + assert "RdsAccount" not in mermaid + assert "RdsPrivilege" not in mermaid + assert "RdsWhitelist" not in mermaid + assert "ReadOnly1" not in mermaid + assert "ReadOnly2" not in mermaid + expected_rds_label = ( + 'RdsInstance["ApsaraDB RDS Instance\\n+ DB account\\n+ Database\\n+ Account privilege' + '\\n+ Access whitelist\\n+ Read-only instance x2"]' + ) + assert expected_rds_label in mermaid + + +def test_compact_graph_folds_ack_application_config_and_wait_steps(): + fillers = [] + for index in range(1, 24): + fillers.append( + f"""\ + Bucket{index}: + Type: ALIYUN::OSS::Bucket +""" + ) + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + VPC: + Type: ALIYUN::ECS::VPC + VSwitch: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: VPC + Ack: + Type: ALIYUN::CS::ManagedKubernetesCluster + Properties: + VpcId: + Ref: VPC + VSwitchIds: + - Ref: VSwitch + AlbConfig: + Type: ALIYUN::CS::ClusterApplication + Properties: + ClusterId: + Ref: Ack + YamlContent: "kind: AlbConfig" + WaitAlb: + Type: ALIYUN::ROS::Sleep + DependsOn: + - AlbConfig + Properties: + CreateDuration: 60 + AppDeploy: + Type: MODULE::ACS::ComputeNest::FluxOciHelmDeploy + Properties: + ClusterId: + Fn::GetAtt: + - Ack + - ClusterId + ReleaseName: app +""" + "".join(fillers) + + result = render_ros_template_architecture( + template, + semantic_plan={ + "edges": [ + { + "from": "AppDeploy", + "to": "Ack", + "kind": "management", + "label": "deploy", + "confidence": "high", + } + ] + }, + ) + mermaid = result.mermaid_source + + assert result.architecture_context["compacted"] is True + assert "AlbConfig" not in mermaid + assert "WaitAlb" not in mermaid + assert 'Ack["ACK Managed Cluster\\n+ ALB ingress config"]' in mermaid + assert 'AppDeploy["ACS::FluxOciHelmDeploy"]' in mermaid + assert "Ack -.- AppDeploy" not in mermaid + assert "AppDeploy -.->|deploy| Ack" in mermaid + assert { + "source": "AppDeploy", + "target": "Ack", + "property": "ClusterId", + "source_type": "MODULE::ACS::ComputeNest::FluxOciHelmDeploy", + "target_type": "ALIYUN::CS::ManagedKubernetesCluster", + "target_visible": True, + } in result.architecture_context["all_property_references"] + + +def test_compact_graph_preserves_ack_cluster_application_manifest_semantics(monkeypatch): + _set_test_language(monkeypatch, "zh") + try: + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + VPC: + Type: ALIYUN::ECS::VPC + VSwitch: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: VPC + Ack: + Type: ALIYUN::CS::ManagedKubernetesCluster + Properties: + VpcId: + Ref: VPC + VSwitchIds: + - Ref: VSwitch + BackendApp: + Type: ALIYUN::CS::ClusterApplication + Properties: + ClusterId: + Ref: Ack + YamlContent: | + apiVersion: apps/v1 + kind: Deployment + metadata: + name: tea + --- + apiVersion: v1 + kind: Service + metadata: + name: tea-svc + AppIngress: + Type: ALIYUN::CS::ClusterApplication + Properties: + ClusterId: + Ref: Ack + YamlContent: + Fn::Sub: |- + apiVersion: networking.k8s.io/v1 + kind: Ingress + metadata: + name: tea-ingress + AppHpa: + Type: ALIYUN::CS::ClusterApplication + Properties: + ClusterId: + Ref: Ack + YamlContent: | + apiVersion: autoscaling/v2 + kind: HorizontalPodAutoscaler + metadata: + name: tea-hpa +""" + _filler_resources() + + result = render_ros_template_architecture(template) + mermaid = result.mermaid_source + + assert result.architecture_context["compacted"] is True + assert "BackendApp" not in mermaid + assert "AppIngress" not in mermaid + assert "AppHpa" not in mermaid + assert "应用工作负载" in mermaid + assert "服务暴露" in mermaid + assert "Ingress入口" in mermaid + assert "HPA弹性伸缩" in mermaid + assert "ACK应用配置" not in mermaid + finally: + _set_test_language(monkeypatch, "en") + + +def test_compact_graph_exposes_ack_hpa_concepts_for_semantic_planning(monkeypatch): + _set_test_language(monkeypatch, "zh") + try: + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + VPC: + Type: ALIYUN::ECS::VPC + VSwitch: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: VPC + Ack: + Type: ALIYUN::CS::ManagedKubernetesCluster + Properties: + VpcId: + Ref: VPC + VSwitchIds: + - Ref: VSwitch + SlsProject: + Type: ALIYUN::SLS::Project + AckMetricsAdapter: + Type: ALIYUN::CS::ClusterHelmApplication + Properties: + ClusterId: + Ref: Ack + ChartUrl: ack-alibaba-cloud-metrics-adapter + BackendApp: + Type: ALIYUN::CS::ClusterApplication + Properties: + ClusterId: + Ref: Ack + YamlContent: | + apiVersion: apps/v1 + kind: Deployment + metadata: + name: tea + --- + apiVersion: v1 + kind: Service + metadata: + name: tea-svc + AppIngress: + Type: ALIYUN::CS::ClusterApplication + Properties: + ClusterId: + Ref: Ack + YamlContent: | + apiVersion: networking.k8s.io/v1 + kind: Ingress + metadata: + name: tea-ingress + AppHpa: + Type: ALIYUN::CS::ClusterApplication + Properties: + ClusterId: + Ref: Ack + YamlContent: + Fn::Sub: | + apiVersion: autoscaling/v2 + kind: HorizontalPodAutoscaler + metadata: + name: tea-hpa + annotations: + sls.project: ${SlsProject} +""" + _filler_resources() + + result = render_ros_template_architecture(template) + context = result.architecture_context + visible_ids = {node["id"] for node in context["visible_nodes"]} + visible_edges = {(edge["from"], edge["to"], edge["label"], edge["style"]) for edge in context["visible_edges"]} + + assert { + "AckApplicationWorkload", + "AckServiceExposure", + "AckIngressEntry", + "AckHpaAutoscaling", + }.issubset(visible_ids) + assert ("AckIngressEntry", "AckServiceExposure", "入口路由", "solid_arrow") in visible_edges + assert ("AckServiceExposure", "AckApplicationWorkload", "服务转发", "solid_arrow") in visible_edges + assert ("AckHpaAutoscaling", "AckApplicationWorkload", "弹性伸缩", "dotted_arrow") in visible_edges + assert ("AckMetricsAdapter", "AckHpaAutoscaling", "指标适配", "dotted_open") in visible_edges + assert ("SlsProject", "AckHpaAutoscaling", "外部指标", "dotted_open") in visible_edges + assert { + "cluster": "Ack", + "source": "AppHpa", + "kind": "HorizontalPodAutoscaler", + "name": "tea-hpa", + "label": "HPA弹性伸缩", + "template_refs": ["SlsProject"], + } in context["kubernetes_applications"] + finally: + _set_test_language(monkeypatch, "en") + + +def test_compact_graph_exposes_helm_application_workload_dependencies(monkeypatch): + _set_test_language(monkeypatch, "zh") + try: + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + VPC: + Type: ALIYUN::ECS::VPC + VSwitch: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: VPC + Ack: + Type: ALIYUN::CS::ManagedKubernetesCluster + Properties: + VpcId: + Ref: VPC + VSwitchIds: + - Ref: VSwitch + AppIngress: + Type: ALIYUN::CS::ClusterApplication + Properties: + ClusterId: + Ref: Ack + YamlContent: | + apiVersion: networking.k8s.io/v1 + kind: Ingress + metadata: + name: app-ingress + spec: + rules: + - http: + paths: + - backend: + service: + name: app + port: + number: 80 + path: / + pathType: Prefix + HelmApp: + Type: MODULE::ACS::ComputeNest::FluxOciHelmDeploy + Properties: + ClusterId: + Fn::GetAtt: + - Ack + - ClusterId + ReleaseName: app + WaitUntil: + - Kind: Deployment + Name: app + Namespace: default + ChartValues: + externalDatabase: + host: + Fn::GetAtt: + - Rds + - ConnectionString + externalRedis: + host: + Fn::GetAtt: + - Redis + - ConnectionDomain + vectorStore: + endpoint: + Fn::GetAtt: + - Gpdb + - ConnectionString + Rds: + Type: ALIYUN::RDS::DBInstance + Redis: + Type: ALIYUN::REDIS::Instance + Gpdb: + Type: ALIYUN::GPDB::DBInstance +""" + _filler_resources() + + result = render_ros_template_architecture(template) + context = result.architecture_context + visible_ids = {node["id"] for node in context["visible_nodes"]} + visible_edges = {(edge["from"], edge["to"], edge["label"], edge["style"]) for edge in context["visible_edges"]} + + assert { + "AckApplicationWorkload", + "AckServiceExposure", + "AckIngressEntry", + }.issubset(visible_ids) + assert ("AckIngressEntry", "AckServiceExposure", "入口路由", "solid_arrow") in visible_edges + assert ("AckServiceExposure", "AckApplicationWorkload", "服务转发", "solid_arrow") in visible_edges + assert ("AckApplicationWorkload", "Rds", "数据库访问", "solid_arrow") in visible_edges + assert ("AckApplicationWorkload", "Redis", "缓存访问", "solid_arrow") in visible_edges + assert ("AckApplicationWorkload", "Gpdb", "向量检索", "solid_arrow") in visible_edges + assert { + "cluster": "Ack", + "source": "HelmApp", + "kind": "Deployment", + "name": "app", + "label": "应用工作负载", + "template_refs": ["Rds", "Redis", "Gpdb"], + } in context["kubernetes_applications"] + finally: + _set_test_language(monkeypatch, "en") + + +def test_compact_graph_folds_sls_logstore_into_project(): + fillers = [] + for index in range(1, 8): + fillers.append( + f"""\ + Bucket{index}: + Type: ALIYUN::OSS::Bucket +""" + ) + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + Project: + Type: ALIYUN::SLS::Project + Logstore: + Type: ALIYUN::SLS::Logstore + Properties: + ProjectName: + Ref: Project +""" + "".join(fillers) + + result = render_ros_template_architecture(template) + mermaid = result.mermaid_source + + assert result.architecture_context["compacted"] is True + assert 'Logstore["SLS Logstore"]' not in mermaid + assert 'Project["SLS Project\\n+ Logstore"]' in mermaid + + +def test_compact_graph_flattens_shared_security_group_without_losing_vswitch_parent(): + fillers = [] + for index in range(1, 24): + fillers.append( + f"""\ + Bucket{index}: + Type: ALIYUN::OSS::Bucket +""" + ) + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + VPC: + Type: ALIYUN::ECS::VPC + VSwitch1: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: VPC + VSwitch2: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: VPC + SG: + Type: ALIYUN::ECS::SecurityGroup + Properties: + VpcId: + Ref: VPC + ECS1: + Type: ALIYUN::ECS::Instance + Properties: + VSwitchId: + Ref: VSwitch1 + SecurityGroupId: + Ref: SG + ECS2: + Type: ALIYUN::ECS::Instance + Properties: + VSwitchId: + Ref: VSwitch2 + SecurityGroupId: + Ref: SG +""" + "".join(fillers) + + mermaid = ros_template_to_mermaid(template) + + assert "subgraph layer_SG [Security group]" not in mermaid + assert 'ECS1["ECS instance 1\\n+ Security group"]' in mermaid + assert 'ECS2["ECS instance 2\\n+ Security group"]' in mermaid + assert 'subgraph layer_VSwitch1 [VSwitch]\n ECS1["ECS instance 1\\n+ Security group"]' in mermaid + assert 'subgraph layer_VSwitch2 [VSwitch]\n ECS2["ECS instance 2\\n+ Security group"]' in mermaid + + +def test_compact_graph_attaches_bound_marker_resources_from_metadata(): + fillers = [] + for index in range(1, 24): + fillers.append( + f"""\ + Bucket{index}: + Type: ALIYUN::OSS::Bucket +""" + ) + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + ECS: + Type: ALIYUN::ECS::Instance + EIP: + Type: ALIYUN::VPC::EIP + EIP2: + Type: ALIYUN::VPC::EIP + EIPAssoc: + Type: ALIYUN::VPC::EIPAssociation + Properties: + AllocationId: + Ref: EIP + InstanceId: + Ref: ECS + EIPAssoc2: + Type: ALIYUN::VPC::EIPAssociation + Properties: + AllocationId: + Ref: EIP2 + InstanceId: + Ref: ECS + HaVip: + Type: ALIYUN::VPC::HaVip + HaVipAssoc: + Type: ALIYUN::VPC::HaVipAssociation + Properties: + HaVipId: + Ref: HaVip + InstanceId: + Ref: ECS +""" + "".join(fillers) + + mermaid = ros_template_to_mermaid(template) + + assert 'ECS["ECS instance\\n+ EIP x2\\n+ HA-VIP"]' in mermaid + assert 'EIP["EIP"]' not in mermaid + assert 'EIP2["EIP"]' not in mermaid + assert "HaVip[" not in mermaid + assert "EIP --> ECS" not in mermaid + assert "HaVip --> ECS" not in mermaid + + +def test_compact_graph_folds_network_interface_and_nested_eip_into_instance(): + fillers = [] + for index in range(1, 24): + fillers.append( + f"""\ + Bucket{index}: + Type: ALIYUN::OSS::Bucket +""" + ) + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + ECS: + Type: ALIYUN::ECS::Instance + ENI: + Type: ALIYUN::ECS::NetworkInterface + ENIAttachment: + Type: ALIYUN::ECS::NetworkInterfaceAttachment + Properties: + NetworkInterfaceId: + Ref: ENI + InstanceId: + Ref: ECS + EIP: + Type: ALIYUN::VPC::EIP + EIPAssoc: + Type: ALIYUN::VPC::EIPAssociation + Properties: + AllocationId: + Ref: EIP + InstanceId: + Ref: ENI +""" + "".join(fillers) + + mermaid = ros_template_to_mermaid(template) + + assert 'ECS["ECS instance\\n+ ENI\\n+ EIP"]' in mermaid + assert 'ENI["ENI"]' not in mermaid + assert 'EIP["EIP"]' not in mermaid + assert "EIP --> ENI" not in mermaid + assert "ENI --> ECS" not in mermaid + + +def test_compact_graph_uses_supplemental_anycast_eip_target_relation(): + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + ECS: + Type: ALIYUN::ECS::Instance + AnycastEIP: + Type: ALIYUN::VPC::AnycastEIP + AnycastAssoc: + Type: ALIYUN::VPC::AnycastEIPAssociation + Properties: + AnycastId: + Ref: AnycastEIP + BindInstanceId: + Ref: ECS + BindInstanceType: ECS + BindInstanceRegionId: cn-hangzhou +""" + _filler_resources() + + mermaid = ros_template_to_mermaid(template) + + assert 'ECS["ECS instance\\n+ Anycast EIP"]' in mermaid + assert 'AnycastEIP["Anycast EIP"]' not in mermaid + assert "AnycastAssoc" not in mermaid + + +def test_compact_graph_can_fold_child_attachment_into_layer_label(): + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + VPC: + Type: ALIYUN::ECS::VPC + VSwitch: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: VPC + CidrBlock: 192.168.0.0/24 + NetworkAcl: + Type: ALIYUN::VPC::NetworkAcl + Properties: + VpcId: + Ref: VPC + NetworkAclAssoc: + Type: ALIYUN::VPC::NetworkAclAssociation + Properties: + NetworkAclId: + Ref: NetworkAcl + Resources: + - ResourceId: + Ref: VSwitch + ResourceType: VSwitch +""" + _filler_resources() + + mermaid = ros_template_to_mermaid(template) + + assert "subgraph layer_VSwitch [VSwitch (192.168.0.0/24)]" in mermaid + assert 'layer_VSwitch_Config["VSwitch configuration\\n+ Associate vSwitch"]' in mermaid + assert "NetworkAclAssoc" not in mermaid + + +def test_compact_graph_bridge_attachment_can_use_auxiliary_via_resource(): + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + VPC: + Type: ALIYUN::ECS::VPC + Dhcp: + Type: ALIYUN::VPC::DhcpOptionsSet + DhcpAttach: + Type: ALIYUN::VPC::DhcpOptionsSetAttachment + Properties: + DhcpOptionsSetId: + Ref: Dhcp + VpcId: + Ref: VPC +""" + _filler_resources() + + mermaid = ros_template_to_mermaid(template) + + assert "subgraph layer_VPC [VPC]" in mermaid + assert 'layer_VPC_Config["VPC configuration\\n+ Associate DHCP Options Set"]' in mermaid + assert 'Dhcp["DHCP Option Set"]' not in mermaid + assert "DhcpAttach" not in mermaid + assert "Associate VPC" not in mermaid + + +def test_compact_graph_bridge_attachment_folds_ecd_network_package(): + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + OfficeSite: + Type: ALIYUN::ECD::SimpleOfficeSite + Package: + Type: ALIYUN::ECD::NetworkPackage + Properties: + OfficeSiteId: + Ref: OfficeSite + PackageAssoc: + Type: ALIYUN::ECD::NetworkPackageAssociation + Properties: + NetworkPackageId: + Ref: Package + OfficeSiteId: + Ref: OfficeSite +""" + _filler_resources() + + mermaid = ros_template_to_mermaid(template) + + assert 'OfficeSite["EDS Convenience Account Office Network\\n+ Bandwidth Plan"]' in mermaid + assert 'Package["EDS Bandwidth Plan"]' not in mermaid + assert "PackageAssoc" not in mermaid + + +def test_compact_graph_bridge_attachment_folds_sag_acl_and_qos(): + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + Sag: + Type: ALIYUN::SAG::SmartAccessGateway + Acl: + Type: ALIYUN::SAG::ACL + AclAssoc: + Type: ALIYUN::SAG::ACLAssociation + Properties: + AclId: + Ref: Acl + SmartAGId: + Ref: Sag + Qos: + Type: ALIYUN::SAG::Qos + QosAssoc: + Type: ALIYUN::SAG::QosAssociation + Properties: + QosId: + Ref: Qos + SmartAGId: + Ref: Sag +""" + _filler_resources() + + mermaid = ros_template_to_mermaid(template) + + assert 'Sag["SAG Instance\\n+ Associate ACL\\n+ Attach QoS Policy"]' in mermaid + assert 'Acl["ACL"]' not in mermaid + assert 'Qos["Qos"]' not in mermaid + assert "AclAssoc" not in mermaid + assert "QosAssoc" not in mermaid + + +def test_compact_graph_hides_unattached_attachment_markers(): + fillers = [] + for index in range(1, 24): + fillers.append( + f"""\ + Bucket{index}: + Type: ALIYUN::OSS::Bucket +""" + ) + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + ECS: + Type: ALIYUN::ECS::Instance + UnusedEIP: + Type: ALIYUN::VPC::EIP + UnusedENI: + Type: ALIYUN::ECS::NetworkInterface +""" + "".join(fillers) + + mermaid = ros_template_to_mermaid(template) + + assert 'ECS["ECS instance"]' in mermaid + assert "UnusedEIP" not in mermaid + assert "UnusedENI" not in mermaid + + +def test_compact_graph_folds_nat_gateway_child_resources(): + fillers = [] + for index in range(1, 24): + fillers.append( + f"""\ + Bucket{index}: + Type: ALIYUN::OSS::Bucket +""" + ) + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + VPC: + Type: ALIYUN::ECS::VPC + VSwitch: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: VPC + NatGateway: + Type: ALIYUN::VPC::NatGateway + Properties: + VpcId: + Ref: VPC + VSwitchId: + Ref: VSwitch + EIP1: + Type: ALIYUN::VPC::EIP + EIP2: + Type: ALIYUN::VPC::EIP + EIPBind1: + Type: ALIYUN::VPC::EIPAssociation + Properties: + AllocationId: + Ref: EIP1 + InstanceId: + Ref: NatGateway + EIPBind2: + Type: ALIYUN::VPC::EIPAssociation + Properties: + AllocationId: + Ref: EIP2 + InstanceId: + Ref: NatGateway + VpcSnat: + Type: ALIYUN::VPC::SnatEntry + Properties: + SnatTableId: + Fn::GetAtt: + - NatGateway + - SNatTableId + EcsSnat: + Type: ALIYUN::ECS::SNatEntry + Properties: + SNatTableId: + Fn::GetAtt: + - NatGateway + - SNatTableId + Dnat: + Type: ALIYUN::VPC::ForwardEntry + Properties: + ForwardTableId: + Fn::GetAtt: + - NatGateway + - ForwardTableId + NatIp: + Type: ALIYUN::VPC::NatIp + Properties: + NatGatewayId: + Ref: NatGateway + NatIpCidr: + Type: ALIYUN::VPC::NatIpCidr + Properties: + NatGatewayId: + Ref: NatGateway +""" + "".join(fillers) + + mermaid = ros_template_to_mermaid(template) + + assert 'NatGateway["NAT gateway\\n+ EIP x2\\n+ SNAT entry x2\\n+ DNAT entry\\n+ NAT IP\\n+ NAT IP CIDR"]' in mermaid + assert 'EIP1["EIP"]' not in mermaid + assert 'EIP2["EIP"]' not in mermaid + assert 'VpcSnat["SNAT Entry"]' not in mermaid + assert 'EcsSnat["SNAT Table"]' not in mermaid + assert 'Dnat["VPC Forward Entry"]' not in mermaid + assert 'NatIp["NAT IP Address"]' not in mermaid + assert 'NatIpCidr["VPC NAT IP CIDR"]' not in mermaid + assert "EIP1 --> NatGateway" not in mermaid + assert "EIP2 --> NatGateway" not in mermaid + + +def test_compact_graph_folds_shared_bandwidth_ip_into_bandwidth_package(): + fillers = [] + for index in range(1, 24): + fillers.append( + f"""\ + Bucket{index}: + Type: ALIYUN::OSS::Bucket +""" + ) + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + BandwidthPackage: + Type: ALIYUN::VPC::CommonBandwidthPackage + BandwidthPackageIp: + Type: ALIYUN::VPC::CommonBandwidthPackageIp + Properties: + BandwidthPackageId: + Ref: BandwidthPackage + ECS: + Type: ALIYUN::ECS::InstanceGroup +""" + "".join(fillers) + + mermaid = ros_template_to_mermaid(template) + + assert 'BandwidthPackage["Shared bandwidth package\\n+ Shared bandwidth IP"]' in mermaid + assert 'BandwidthPackageIp["Internet Shared Bandwidth Instance IP"]' not in mermaid + + +def test_compact_graph_keeps_shared_bandwidth_package_connected_to_eip_owner(): + fillers = [] + for index in range(1, 24): + fillers.append( + f"""\ + Bucket{index}: + Type: ALIYUN::OSS::Bucket +""" + ) + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + BandwidthPackage: + Type: ALIYUN::VPC::CommonBandwidthPackage + BandwidthPackageIp: + Type: ALIYUN::VPC::CommonBandwidthPackageIp + Properties: + BandwidthPackageId: + Ref: BandwidthPackage + Eips: + - AllocationId: + Ref: EIP + EIP: + Type: ALIYUN::VPC::EIP + EIPAssociation: + Type: ALIYUN::VPC::EIPAssociation + Properties: + AllocationId: + Ref: EIP + InstanceId: + Ref: ECS + ECS: + Type: ALIYUN::ECS::InstanceGroup +""" + "".join(fillers) + + result = render_ros_template_architecture(template) + mermaid = result.mermaid_source + + assert 'BandwidthPackage["Shared bandwidth package\\n+ Shared bandwidth IP"]' in mermaid + assert 'ECS["ECS instance group\\n+ EIP"]' in mermaid + assert "BandwidthPackage -.-|public bandwidth| ECS" in mermaid + assert 'BandwidthPackageIp["Internet Shared Bandwidth Instance IP"]' not in mermaid + assert 'EIP["EIP"]' not in mermaid + assert { + "from": "BandwidthPackage", + "to": "ECS", + "style": "dotted_open", + "label": "public bandwidth", + } in result.architecture_context["visible_edges"] + + +def test_semantic_plan_does_not_override_labeled_shared_bandwidth_relation(monkeypatch): + _set_test_language(monkeypatch, "zh") + try: + fillers = [] + for index in range(1, 24): + fillers.append( + f"""\ + Bucket{index}: + Type: ALIYUN::OSS::Bucket +""" + ) + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + BandwidthPackage: + Type: ALIYUN::VPC::CommonBandwidthPackage + BandwidthPackageIp: + Type: ALIYUN::VPC::CommonBandwidthPackageIp + Properties: + BandwidthPackageId: + Ref: BandwidthPackage + Eips: + - AllocationId: + Ref: EIP + EIP: + Type: ALIYUN::VPC::EIP + EIPAssociation: + Type: ALIYUN::VPC::EIPAssociation + Properties: + AllocationId: + Ref: EIP + InstanceId: + Ref: ECS + ECS: + Type: ALIYUN::ECS::InstanceGroup +""" + "".join(fillers) + + result = render_ros_template_architecture( + template, + semantic_plan={ + "edges": [ + { + "from": "BandwidthPackage", + "to": "ECS", + "kind": "traffic", + "label": "提供公网带宽", + "confidence": "high", + } + ] + }, + ) + mermaid = result.mermaid_source + + assert "BandwidthPackage -.-|公网带宽| ECS" in mermaid + assert "BandwidthPackage -->|提供公网带宽| ECS" not in mermaid + assert result.architecture_context["semantic_plan"]["accepted_edges"] == [] + assert result.architecture_context["semantic_plan"]["rejected_edges"] == [ + { + "from": "BandwidthPackage", + "to": "ECS", + "reason": "covered by deterministic edge", + } + ] + finally: + _set_test_language(monkeypatch, "en") + + +def test_compact_graph_folds_network_control_plane_and_rewrites_hidden_semantic_edges(monkeypatch): + _set_test_language(monkeypatch, "en") + try: + fillers = _filler_resources(22) + template = ( + """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + VPC: + Type: ALIYUN::ECS::VPC + Properties: + CidrBlock: 192.168.0.0/16 + VSwitch: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: VPC + CidrBlock: 192.168.0.0/24 + Route: + Type: ALIYUN::ECS::Route + Properties: + RouteTableId: + Fn::GetAtt: + - VPC + - RouteTableId + BandwidthPackage: + Type: ALIYUN::VPC::CommonBandwidthPackage + NLB: + Type: ALIYUN::NLB::LoadBalancer + Properties: + VpcId: + Ref: VPC + BandwidthPackageId: + Ref: BandwidthPackage + NLBServerGroup: + Type: ALIYUN::NLB::ServerGroup + Properties: + VpcId: + Ref: VPC + Servers: + - ServerId: + Fn::GetAtt: + - ALB + - LoadBalancerId + NLBListener: + Type: ALIYUN::NLB::Listener + Properties: + LoadBalancerId: + Ref: NLB + ServerGroupId: + Ref: NLBServerGroup + ALB: + Type: ALIYUN::ALB::LoadBalancer + Properties: + VpcId: + Ref: VPC + ALBServerGroup: + Type: ALIYUN::ALB::ServerGroup + Properties: + VpcId: + Ref: VPC + ALBListener: + Type: ALIYUN::ALB::Listener + Properties: + LoadBalancerId: + Ref: ALB + DefaultActions: + - ForwardGroupConfig: + ServerGroupTuples: + - ServerGroupId: + Ref: ALBServerGroup + ALBBackend: + Type: ALIYUN::ALB::BackendServerAttachment + Properties: + ServerGroupId: + Ref: ALBServerGroup + Servers: + - ServerId: + Ref: ECS + ECS: + Type: ALIYUN::ECS::Instance + Properties: + VSwitchId: + Ref: VSwitch + CEN: + Type: ALIYUN::CEN::CenInstance + TransitRouter: + Type: ALIYUN::CEN::TransitRouter + Properties: + CenId: + Ref: CEN + VpcAttachment: + Type: ALIYUN::CEN::TransitRouterVpcAttachment + Properties: + TransitRouterId: + Ref: TransitRouter + VpcId: + Ref: VPC + RouteTable: + Type: ALIYUN::CEN::TransitRouterRouteTable + Properties: + TransitRouterId: + Ref: TransitRouter + RouteAssociation: + Type: ALIYUN::CEN::TransitRouterRouteTableAssociation + Properties: + TransitRouterRouteTableId: + Ref: RouteTable + TransitRouterAttachmentId: + Ref: VpcAttachment + RoutePropagation: + Type: ALIYUN::CEN::TransitRouterRouteTablePropagation + Properties: + TransitRouterRouteTableId: + Ref: RouteTable + TransitRouterAttachmentId: + Ref: VpcAttachment + RoutePropagationDefault: + Type: ALIYUN::CEN::TransitRouterRouteTablePropagation + Properties: + TransitRouterRouteTableId: + Fn::GetAtt: + - TransitRouter + - SystemTransitRouterRouteTableId + TransitRouterAttachmentId: + Ref: VpcAttachment + RouteEntry: + Type: ALIYUN::CEN::TransitRouterRouteEntry + Properties: + TransitRouterRouteTableId: + Ref: RouteTable + TransitRouterRouteEntryNextHopId: + Ref: VpcAttachment +""" + + fillers + ) + + result = render_ros_template_architecture( + template, + semantic_plan={ + "edges": [ + { + "from": "NLBServerGroup", + "to": "ALB", + "kind": "traffic", + "label": "backend", + "confidence": "high", + }, + { + "from": "ALBServerGroup", + "to": "ECS", + "kind": "traffic", + "label": "backend", + "confidence": "high", + }, + ] + }, + ) + mermaid = result.mermaid_source + + assert "NLBServerGroup" not in mermaid + assert "ALBServerGroup" not in mermaid + assert 'BandwidthPackage["Shared bandwidth package"]' not in mermaid + assert 'Route["Route"]' not in mermaid + assert 'RouteTable["CEN Route Table' not in mermaid + assert 'RoutePropagation["CEN Route Learning Correlation"]' not in mermaid + assert 'RoutePropagationDefault["' not in mermaid + assert 'VpcAttachment["Connect VPC to Transit Router via CEN"]' not in mermaid + assert "subgraph layer_VPC [VPC (192.168.0.0/16)]" in mermaid + assert 'layer_VPC_Config["VPC configuration\\n+ Route"]' in mermaid + assert 'NLB["NLB Instance\\n+ Listener\\n+ Shared bandwidth package\\n+ NLB server group"]' in mermaid + assert 'ALB["ALB Instance\\n+ Listener\\n+ ALB server group\\n+ Attach Backend Server"]' in mermaid + assert 'TransitRouter["CEN Transit Router' in mermaid + assert "\\n+ VPC connection" in mermaid + assert "\\n+ CEN route table" in mermaid + assert "\\n+ Route Learning" in mermaid + assert "TransitRouter -.-|VPC connection| layer_VPC_Config" not in mermaid + assert "TransitRouter -.-|VPC connection| layer_VPC\n" not in mermaid + assert "NLB -->|backend| ALB" in mermaid + assert "ALB -->|backend| ECS" in mermaid + assert { + "from": "NLB", + "to": "ALB", + "kind": "traffic", + "label": "backend", + "confidence": "high", + } in result.architecture_context["semantic_plan"]["accepted_edges"] + assert { + "from": "ALB", + "to": "ECS", + "kind": "traffic", + "label": "backend", + "confidence": "high", + } in result.architecture_context["semantic_plan"]["accepted_edges"] + finally: + _set_test_language(monkeypatch, "en") + + +def test_architecture_context_keeps_route_next_hop_relations_for_hidden_routes(): + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + VpcSec: + Type: ALIYUN::ECS::VPC + VSwitchSec: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: VpcSec + SecurityGroup: + Type: ALIYUN::ECS::SecurityGroup + Properties: + VpcId: + Ref: VpcSec + ForwarderGroup: + Type: ALIYUN::ECS::InstanceGroup + Properties: + VSwitchId: + Ref: VSwitchSec + SecurityGroupId: + Ref: SecurityGroup + TransitRouter: + Type: ALIYUN::CEN::TransitRouter + VpcSecAttachment: + Type: ALIYUN::CEN::TransitRouterVpcAttachment + Properties: + TransitRouterId: + Ref: TransitRouter + VpcId: + Ref: VpcSec + VpcSecRouteTable: + Type: ALIYUN::VPC::RouteTable + Properties: + VpcId: + Ref: VpcSec + RouteForwardToEcs: + Type: ALIYUN::ECS::Route + Properties: + RouteTableId: + Fn::GetAtt: + - VpcSec + - RouteTableId + DestinationCidrBlock: 0.0.0.0/0 + NextHopType: Instance + NextHopId: + Fn::Select: + - 0 + - Fn::GetAtt: + - ForwarderGroup + - InstanceIds + RouteForwardToCen: + Type: ALIYUN::ECS::Route + Properties: + RouteTableId: + Ref: VpcSecRouteTable + DestinationCidrBlock: 0.0.0.0/0 + NextHopType: Attachment + NextHopId: + Ref: VpcSecAttachment + TransitRouterRouteTable: + Type: ALIYUN::CEN::TransitRouterRouteTable + Properties: + TransitRouterId: + Ref: TransitRouter + TransitRouterDefaultRoute: + Type: ALIYUN::CEN::TransitRouterRouteEntry + Properties: + TransitRouterRouteTableId: + Ref: TransitRouterRouteTable + DestinationCidrBlock: 0.0.0.0/0 + TransitRouterRouteEntryNextHopId: + Ref: VpcSecAttachment +""" + + result = render_ros_template_architecture(template) + + assert { + "source": "RouteForwardToEcs", + "target": "ForwarderGroup", + "property": "NextHopId", + "source_type": "ALIYUN::ECS::Route", + "target_type": "ALIYUN::ECS::InstanceGroup", + } in result.architecture_context["explicit_relations"] + assert { + "source": "RouteForwardToCen", + "target": "VpcSecAttachment", + "property": "NextHopId", + "source_type": "ALIYUN::ECS::Route", + "target_type": "ALIYUN::CEN::TransitRouterVpcAttachment", + } in result.architecture_context["explicit_relations"] + assert { + "source": "TransitRouterDefaultRoute", + "target": "VpcSecAttachment", + "property": "TransitRouterRouteEntryNextHopId", + "source_type": "ALIYUN::CEN::TransitRouterRouteEntry", + "target_type": "ALIYUN::CEN::TransitRouterVpcAttachment", + } in result.architecture_context["explicit_relations"] + assert { + "id": "RouteForwardToEcs", + "type": "ALIYUN::ECS::Route", + "destination": "0.0.0.0/0", + "route_table": "VpcSec", + "route_table_resource": "VpcSec", + "route_table_resource_type": "ALIYUN::ECS::VPC", + "next_hop_type": "Instance", + "next_hop": "ForwarderGroup", + "next_hop_resource": "ForwarderGroup", + "next_hop_resource_type": "ALIYUN::ECS::InstanceGroup", + } in result.architecture_context["route_intents"] + assert { + "id": "RouteForwardToCen", + "type": "ALIYUN::ECS::Route", + "destination": "0.0.0.0/0", + "route_table": "VpcSecRouteTable", + "route_table_resource": "VpcSecRouteTable", + "route_table_resource_type": "ALIYUN::VPC::RouteTable", + "next_hop_type": "Attachment", + "next_hop": "VpcSecAttachment", + "next_hop_resource": "VpcSecAttachment", + "next_hop_resource_type": "ALIYUN::CEN::TransitRouterVpcAttachment", + } in result.architecture_context["route_intents"] + assert { + "id": "TransitRouterDefaultRoute", + "type": "ALIYUN::CEN::TransitRouterRouteEntry", + "destination": "0.0.0.0/0", + "route_table": "TransitRouterRouteTable", + "route_table_resource": "TransitRouterRouteTable", + "route_table_resource_type": "ALIYUN::CEN::TransitRouterRouteTable", + "next_hop": "VpcSecAttachment", + "next_hop_resource": "VpcSecAttachment", + "next_hop_resource_type": "ALIYUN::CEN::TransitRouterVpcAttachment", + } in result.architecture_context["route_intents"] + + +def test_compact_graph_counts_network_layers_as_visible_complexity(monkeypatch): + _set_test_language(monkeypatch, "en") + try: + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + CEN: + Type: ALIYUN::CEN::CenInstance + TransitRouter: + Type: ALIYUN::CEN::TransitRouter + Properties: + CenId: + Ref: CEN + VPC1: + Type: ALIYUN::ECS::VPC + Properties: + CidrBlock: 10.1.0.0/16 + VPC2: + Type: ALIYUN::ECS::VPC + Properties: + CidrBlock: 10.2.0.0/16 + VPC3: + Type: ALIYUN::ECS::VPC + Properties: + CidrBlock: 10.3.0.0/16 + CustomRouteTable1: + Type: ALIYUN::VPC::RouteTable + Properties: + VpcId: + Ref: VPC1 + VSwitch1A: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: VPC1 + CidrBlock: 10.1.0.0/24 + VSwitch1B: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: VPC1 + CidrBlock: 10.1.1.0/24 + VSwitch1C: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: VPC1 + CidrBlock: 10.1.2.0/24 + VSwitch2A: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: VPC2 + CidrBlock: 10.2.0.0/24 + VSwitch2B: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: VPC2 + CidrBlock: 10.2.1.0/24 + VSwitch2C: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: VPC2 + CidrBlock: 10.2.2.0/24 + VSwitch3A: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: VPC3 + CidrBlock: 10.3.0.0/24 + VSwitch3B: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: VPC3 + CidrBlock: 10.3.1.0/24 + VSwitch3C: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: VPC3 + CidrBlock: 10.3.2.0/24 + SecurityGroup1: + Type: ALIYUN::ECS::SecurityGroup + Properties: + VpcId: + Ref: VPC1 + SecurityGroup2: + Type: ALIYUN::ECS::SecurityGroup + Properties: + VpcId: + Ref: VPC2 + SecurityGroup3: + Type: ALIYUN::ECS::SecurityGroup + Properties: + VpcId: + Ref: VPC3 + ECS1: + Type: ALIYUN::ECS::Instance + Properties: + VSwitchId: + Ref: VSwitch1C + SecurityGroupId: + Ref: SecurityGroup1 + ECS2: + Type: ALIYUN::ECS::Instance + Properties: + VSwitchId: + Ref: VSwitch2C + SecurityGroupId: + Ref: SecurityGroup2 + ECS3: + Type: ALIYUN::ECS::Instance + Properties: + VSwitchId: + Ref: VSwitch3C + SecurityGroupId: + Ref: SecurityGroup3 + Route1: + Type: ALIYUN::ECS::Route + Properties: + RouteTableId: + Fn::GetAtt: + - VPC1 + - RouteTableId + Route2: + Type: ALIYUN::ECS::Route + Properties: + RouteTableId: + Fn::GetAtt: + - VPC2 + - RouteTableId + RouteToCustomTable: + Type: ALIYUN::ECS::Route + Properties: + RouteTableId: + Ref: CustomRouteTable1 + VpcAttachment1: + Type: ALIYUN::CEN::TransitRouterVpcAttachment + Properties: + TransitRouterId: + Ref: TransitRouter + VpcId: + Ref: VPC1 + VpcAttachment2: + Type: ALIYUN::CEN::TransitRouterVpcAttachment + Properties: + TransitRouterId: + Ref: TransitRouter + VpcId: + Ref: VPC2 + VpcAttachment3: + Type: ALIYUN::CEN::TransitRouterVpcAttachment + Properties: + TransitRouterId: + Ref: TransitRouter + VpcId: + Ref: VPC3 + RouteTable: + Type: ALIYUN::CEN::TransitRouterRouteTable + Properties: + TransitRouterId: + Ref: TransitRouter + RoutePropagation: + Type: ALIYUN::CEN::TransitRouterRouteTablePropagation + Properties: + TransitRouterRouteTableId: + Ref: RouteTable + TransitRouterAttachmentId: + Ref: VpcAttachment1 +""" + + result = render_ros_template_architecture(template) + mermaid = result.mermaid_source + + assert result.architecture_context["compacted"] is True + assert 'Route1["Route"]' not in mermaid + assert 'CustomRouteTable1["VPC Route Table"]' not in mermaid + assert 'RouteToCustomTable["Route"]' not in mermaid + assert 'RouteTable["CEN Route Table' not in mermaid + assert 'RoutePropagation["CEN Route Learning Correlation"]' not in mermaid + assert 'TransitRouter["CEN Transit Router' in mermaid + assert "\\n+ VPC connection x3" in mermaid + assert "\\n+ CEN route table" in mermaid + assert "\\n+ Route Learning" in mermaid + assert 'layer_VPC1_Config["VPC configuration\\n+ VPC route table\\n+ Route x2"]' in mermaid + finally: + _set_test_language(monkeypatch, "en") + + +def test_compact_graph_folds_nas_mount_and_access_control_into_file_system(): + fillers = [] + for index in range(1, 19): + fillers.append( + f"""\ + Bucket{index}: + Type: ALIYUN::OSS::Bucket +""" + ) + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + VPC: + Type: ALIYUN::ECS::VPC + VSwitch: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: VPC + SecurityGroup: + Type: ALIYUN::ECS::SecurityGroup + Properties: + VpcId: + Ref: VPC + EcsGroup: + Type: ALIYUN::ECS::InstanceGroup + Properties: + VSwitchId: + Ref: VSwitch + SecurityGroupId: + Ref: SecurityGroup + UserData: + Fn::Join: + - '' + - - 'mount -t nfs ' + - Fn::GetAtt: + - NasMountTarget + - MountTargetDomain + - ':/ /mnt' + NasAccessGroup: + Type: ALIYUN::NAS::AccessGroup + NasAccessRule: + Type: ALIYUN::NAS::AccessRule + Properties: + AccessGroupName: + Ref: NasAccessGroup + NasFileSystem: + Type: ALIYUN::NAS::FileSystem + NasMountTarget: + Type: ALIYUN::NAS::MountTarget + Properties: + VpcId: + Ref: VPC + VSwitchId: + Ref: VSwitch + AccessGroupName: + Ref: NasAccessGroup + FileSystemId: + Ref: NasFileSystem + DependsOn: + - NasAccessRule +""" + "".join(fillers) + + result = render_ros_template_architecture(template) + mermaid = result.mermaid_source + + assert ( + 'NasFileSystem["NAS File System\\n+ NAS mount target\\n+ NAS permission group\\n+ NAS permission rule"]' + in mermaid + ) + assert 'NasMountTarget["NAS Mount Target"]' not in mermaid + assert 'NasAccessGroup["NAS Permission Group"]' not in mermaid + assert 'NasAccessRule["NAS Permission Group Rule"]' not in mermaid + assert { + "source": "EcsGroup", + "target": "NasMountTarget", + "property": "UserData", + "source_type": "ALIYUN::ECS::InstanceGroup", + "target_type": "ALIYUN::NAS::MountTarget", + "target_visible": False, + } in result.architecture_context["all_property_references"] + + +def test_compact_graph_hides_cloud_assistant_nodes_but_keeps_orchestration_context(): + fillers = [] + for index in range(1, 18): + fillers.append( + f"""\ + Bucket{index}: + Type: ALIYUN::OSS::Bucket +""" + ) + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + VPC: + Type: ALIYUN::ECS::VPC + VSwitch: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: VPC + SecurityGroup: + Type: ALIYUN::ECS::SecurityGroup + Properties: + VpcId: + Ref: VPC + EcsGroup: + Type: ALIYUN::ECS::InstanceGroup + Properties: + VSwitchId: + Ref: VSwitch + SecurityGroupId: + Ref: SecurityGroup + NasFileSystem: + Type: ALIYUN::NAS::FileSystem + NasMountTarget: + Type: ALIYUN::NAS::MountTarget + Properties: + VpcId: + Ref: VPC + VSwitchId: + Ref: VSwitch + FileSystemId: + Ref: NasFileSystem + EcsCommand: + Type: ALIYUN::ECS::Command + Properties: + CommandContent: + Fn::Base64Encode: + Fn::Join: + - '' + - - 'mount -t nfs ' + - Fn::GetAtt: + - NasMountTarget + - MountTargetDomain + - ':/ /mnt' + Type: RunShellScript + EcsInvocation: + Type: ALIYUN::ECS::Invocation + Properties: + InstanceIds: + Fn::GetAtt: + - EcsGroup + - InstanceIds + CommandId: + Ref: EcsCommand +""" + "".join(fillers) + + result = render_ros_template_architecture(template) + mermaid = result.mermaid_source + + assert 'EcsCommand["Cloud Assistant Command"]' not in mermaid + assert 'EcsInvocation["Cloud Assistant Invocation"]' not in mermaid + assert 'EcsGroup["ECS instance group\\n+ Security group"]' in mermaid + assert 'NasFileSystem["NAS File System\\n+ NAS mount target"]' in mermaid + assert result.architecture_context["orchestration_actions"] == [ + { + "id": "EcsInvocation", + "type": "ALIYUN::ECS::Invocation", + "command": "EcsCommand", + "targets": [ + { + "id": "EcsGroup", + "type": "ALIYUN::ECS::InstanceGroup", + "property": "InstanceIds", + "visible": True, + } + ], + "referenced_resources": [ + { + "id": "NasMountTarget", + "type": "ALIYUN::NAS::MountTarget", + "property": "CommandContent", + "visible": False, + } + ], + } + ] + + +def test_run_command_extracts_fn_sub_references_from_inline_command_content(): + template = """\ +ROSTemplateFormatVersion: '2015-09-01' +Resources: + VPC: + Type: ALIYUN::ECS::VPC + VSwitch: + Type: ALIYUN::ECS::VSwitch + Properties: + VpcId: + Ref: VPC + SecurityGroup: + Type: ALIYUN::ECS::SecurityGroup + Properties: + VpcId: + Ref: VPC + AppGroup1: + Type: ALIYUN::ECS::InstanceGroup + Properties: + VSwitchId: + Ref: VSwitch + SecurityGroupId: + Ref: SecurityGroup + AppGroup2: + Type: ALIYUN::ECS::InstanceGroup + Properties: + VSwitchId: + Ref: VSwitch + SecurityGroupId: + Ref: SecurityGroup + RedisInstance: + Type: ALIYUN::REDIS::Instance + Properties: + VpcId: + Ref: VPC + VSwitchId: + Ref: VSwitch + PolarDBCluster: + Type: ALIYUN::POLARDB::DBCluster + Properties: + VpcId: + Ref: VPC + VSwitchId: + Ref: VSwitch + InstanceRunCommand: + Type: ALIYUN::ECS::RunCommand + Properties: + InstanceIds: + - Fn::GetAtt: + - AppGroup1 + - InstanceIds + - Fn::GetAtt: + - AppGroup2 + - InstanceIds + Type: RunShellScript + CommandContent: + Fn::Sub: |- + export REDIS_HOST="${RedisInstance.ConnectionDomain}" + export DB_URL="${PolarDBCluster.PrimaryConnectionString}:3306/app" +""" + + result = render_ros_template_architecture(template) + + assert result.architecture_context["orchestration_actions"] == [ + { + "id": "InstanceRunCommand", + "type": "ALIYUN::ECS::RunCommand", + "command": None, + "targets": [ + { + "id": "AppGroup1", + "type": "ALIYUN::ECS::InstanceGroup", + "property": "InstanceIds", + "visible": True, + }, + { + "id": "AppGroup2", + "type": "ALIYUN::ECS::InstanceGroup", + "property": "InstanceIds", + "visible": True, + }, + ], + "referenced_resources": [ + { + "id": "RedisInstance", + "type": "ALIYUN::REDIS::Instance", + "property": "CommandContent", + "visible": True, + }, + { + "id": "PolarDBCluster", + "type": "ALIYUN::POLARDB::DBCluster", + "property": "CommandContent", + "visible": True, + }, + ], + } + ] diff --git a/tests/pipeline/engine/test_architecture_meta.py b/tests/pipeline/engine/test_architecture_meta.py new file mode 100644 index 00000000..41b46068 --- /dev/null +++ b/tests/pipeline/engine/test_architecture_meta.py @@ -0,0 +1,41 @@ +from iac_code.pipeline.engine.architecture_meta import ArchitectureMetaRepository, normalize_resource_type + + +def test_normalize_resource_type_strips_ros_prefix(): + assert normalize_resource_type("ROS/ALIYUN::ECS::VPC") == "ALIYUN::ECS::VPC" + assert normalize_resource_type("ALIYUN::ECS::VPC") == "ALIYUN::ECS::VPC" + assert normalize_resource_type("Terraform/alicloud_vpc") is None + + +def test_default_repository_loads_vendored_raw_metas(): + repo = ArchitectureMetaRepository.load_default() + + ecs = repo.get_resource("ALIYUN::ECS::Instance") + assert ecs is not None + assert ecs.name_en == "ECS Instance" + assert ecs.product_code == "ecs" + assert ecs.category_code == "computing" + + related = ecs.related_properties_by_name["VSwitchId"] + assert related.targets == ("ALIYUN::ECS::VSwitch",) + + +def test_repository_normalizes_main_resource_type(): + repo = ArchitectureMetaRepository.load_default() + + attachment = repo.get_resource("ALIYUN::VPC::EIPAssociation") + + assert attachment is not None + assert attachment.main_resource_type is not None + assert attachment.main_resource_type.resource_type == "ALIYUN::VPC::EIP" + assert attachment.main_resource_type.ref_property == "AllocationId" + + +def test_repository_maps_product_to_category(): + repo = ArchitectureMetaRepository.load_default() + + product = repo.get_product("rds") + + assert product is not None + assert product.name_en == "ApsaraDB RDS" + assert repo.category_code_for_product("rds") == "database" diff --git a/tests/pipeline/engine/test_architecture_resource_inventory.py b/tests/pipeline/engine/test_architecture_resource_inventory.py new file mode 100644 index 00000000..bf5812e9 --- /dev/null +++ b/tests/pipeline/engine/test_architecture_resource_inventory.py @@ -0,0 +1,183 @@ +from __future__ import annotations + +from pathlib import Path +from typing import Any + +import pytest + +from iac_code.pipeline.engine.architecture_meta import ArchitectureMetaRepository +from iac_code.pipeline.engine.architecture_resource_inventory import ( + RosResourceTypeDetail, + build_resource_inventory_snapshot, + collect_ros_resource_inventory, +) + + +def _meta_repo() -> ArchitectureMetaRepository: + return ArchitectureMetaRepository.from_raw( + categories=[ + {"CategoryCode": "network", "ProductCodes": ["ecs", "vpc"]}, + {"CategoryCode": "database", "ProductCodes": ["polardb"]}, + ], + products=[ + {"ProductCode": "ecs", "Name": {"en": "ECS", "zh": "云服务器"}, "RelevantCodes": {"ROS": "ECS"}}, + {"ProductCode": "vpc", "Name": {"en": "VPC", "zh": "专有网络"}, "RelevantCodes": {"ROS": "VPC"}}, + { + "ProductCode": "polardb", + "Name": {"en": "PolarDB", "zh": "云原生数据库"}, + "RelevantCodes": {"ROS": "POLARDB"}, + }, + ], + config=[ + { + "ResourceType": {"ROS": "ROS/ALIYUN::ECS::VPC"}, + "ProductCode": "ecs", + "Name": {"en": "VPC", "zh": "专有网络 VPC"}, + "Properties": [], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::POLARDB::DBCluster"}, + "ProductCode": "polardb", + "Name": {"en": "PolarDB Cluster", "zh": "PolarDB 集群"}, + "Properties": [ + { + "ROS": "VpcId", + "Type": "String", + "RelatedTo": [{"ResourceType": "ROS/ALIYUN::ECS::VPC"}], + } + ], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::OLD::Gone"}, + "ProductCode": "old", + "Name": {"en": "Old Gone", "zh": "旧资源"}, + "Properties": [], + }, + ], + ) + + +def test_build_snapshot_uses_list_resource_types_as_authority() -> None: + snapshot = build_resource_inventory_snapshot( + api_resource_types=[ + "ALIYUN::ECS::VPC", + "ALIYUN::POLARDB::DBCluster", + "ALIYUN::VPC::IpamPool", + ], + details_by_type={ + "ALIYUN::ECS::VPC": RosResourceTypeDetail( + resource_type="ALIYUN::ECS::VPC", + entity_type="Resource", + provider="ROS", + properties={}, + attributes={}, + support_drift_detection=True, + support_scratch_detection=True, + ), + "ALIYUN::VPC::IpamPool": RosResourceTypeDetail( + resource_type="ALIYUN::VPC::IpamPool", + entity_type="Resource", + provider="ROS", + properties={"IpamPoolName": {"Type": "string", "Description": "The name of the IPAM pool."}}, + attributes={}, + ), + }, + meta_repository=_meta_repo(), + fetched_at="2026-06-26T00:00:00Z", + ) + + assert snapshot.api_resource_types == ( + "ALIYUN::ECS::VPC", + "ALIYUN::POLARDB::DBCluster", + "ALIYUN::VPC::IpamPool", + ) + assert snapshot.local_resource_types == ( + "ALIYUN::ECS::VPC", + "ALIYUN::OLD::Gone", + "ALIYUN::POLARDB::DBCluster", + ) + assert snapshot.api_only_resource_types == ("ALIYUN::VPC::IpamPool",) + assert snapshot.local_only_resource_types == ("ALIYUN::OLD::Gone",) + + vpc = snapshot.items["ALIYUN::ECS::VPC"] + assert vpc.source_state == "api+local" + assert vpc.product_code == "ecs" + assert vpc.category_code == "network" + assert vpc.name_zh == "专有网络 VPC" + + ipam_pool = snapshot.items["ALIYUN::VPC::IpamPool"] + assert ipam_pool.source_state == "api-only" + assert ipam_pool.product_code == "vpc" + assert ipam_pool.detail is not None + assert ipam_pool.detail.properties["IpamPoolName"]["Description"] == "The name of the IPAM pool." + + +class _FakeRosResourceTypeClient: + def __init__(self) -> None: + self.fetched: list[str] = [] + + async def list_resource_types(self) -> list[str]: + return ["ALIYUN::ECS::VPC", "ALIYUN::VPC::SnatEntry", "ALIYUN::VPC::Cached"] + + async def get_resource_type(self, resource_type: str) -> dict[str, Any]: + self.fetched.append(resource_type) + if resource_type == "ALIYUN::VPC::SnatEntry": + raise RuntimeError("temporary throttling") + return { + "ResourceType": resource_type, + "EntityType": "Resource", + "Provider": "ROS", + "Properties": { + "VpcName": { + "Type": "string", + "Required": False, + "Description": "The name of the VPC.", + } + }, + "Attributes": {"VpcId": {"Description": "The ID of the VPC."}}, + "SupportDriftDetection": True, + "SupportScratchDetection": False, + } + + +@pytest.mark.asyncio +async def test_collect_inventory_uses_cache_and_records_fetch_errors(tmp_path: Path) -> None: + cache_path = tmp_path / "ros-resource-types.json" + cache_path.write_text( + """{ + "resource_types": ["ALIYUN::VPC::Cached"], + "details": { + "ALIYUN::VPC::Cached": { + "resource_type": "ALIYUN::VPC::Cached", + "entity_type": "Resource", + "provider": "ROS", + "properties": {"CachedId": {"Description": "Cached detail."}}, + "attributes": {}, + "support_drift_detection": false, + "support_scratch_detection": false + } + }, + "errors": {} +} +""", + encoding="utf-8", + ) + client = _FakeRosResourceTypeClient() + + snapshot = await collect_ros_resource_inventory( + client=client, + cache_path=cache_path, + meta_repository=_meta_repo(), + fetched_at="2026-06-26T00:00:00Z", + ) + + assert client.fetched == ["ALIYUN::ECS::VPC", "ALIYUN::VPC::SnatEntry"] + assert "ALIYUN::VPC::Cached" in snapshot.items + assert snapshot.items["ALIYUN::VPC::Cached"].detail is not None + assert snapshot.fetch_errors == {"ALIYUN::VPC::SnatEntry": "temporary throttling"} + + cached = cache_path.read_text(encoding="utf-8") + assert "ALIYUN::ECS::VPC" in cached + assert "ALIYUN::VPC::Cached" in cached + assert "temporary throttling" in cached + assert "access_key" not in cached.lower() diff --git a/tests/pipeline/engine/test_architecture_rule_candidates.py b/tests/pipeline/engine/test_architecture_rule_candidates.py new file mode 100644 index 00000000..48668a7c --- /dev/null +++ b/tests/pipeline/engine/test_architecture_rule_candidates.py @@ -0,0 +1,353 @@ +from __future__ import annotations + +from iac_code.pipeline.engine.architecture_meta import ArchitectureMetaRepository +from iac_code.pipeline.engine.architecture_resource_inventory import ( + RosResourceTypeDetail, + build_resource_inventory_snapshot, +) +from iac_code.pipeline.engine.architecture_rule_candidates import ( + build_resource_type_decisions, + extract_rule_candidates, + render_rule_candidate_report_markdown, +) + + +def _repo() -> ArchitectureMetaRepository: + def prop(name: str, target: str) -> dict: + return {"ROS": name, "Type": "String", "RelatedTo": [{"ResourceType": f"ROS/{target}"}]} + + return ArchitectureMetaRepository.from_raw( + categories=[ + {"CategoryCode": "network", "ProductCodes": ["ecs", "vpc"]}, + {"CategoryCode": "storage", "ProductCodes": ["nas"]}, + {"CategoryCode": "compute", "ProductCodes": ["ess"]}, + ], + products=[ + {"ProductCode": "ecs", "Name": {"en": "ECS", "zh": "云服务器"}, "RelevantCodes": {"ROS": "ECS"}}, + {"ProductCode": "vpc", "Name": {"en": "VPC", "zh": "专有网络"}, "RelevantCodes": {"ROS": "VPC"}}, + {"ProductCode": "nas", "Name": {"en": "NAS", "zh": "文件存储"}, "RelevantCodes": {"ROS": "NAS"}}, + {"ProductCode": "ess", "Name": {"en": "ESS", "zh": "弹性伸缩"}, "RelevantCodes": {"ROS": "ESS"}}, + ], + config=[ + { + "ResourceType": {"ROS": "ROS/ALIYUN::ECS::VPC"}, + "ProductCode": "ecs", + "Name": {"en": "VPC", "zh": "专有网络 VPC"}, + "Properties": [], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::ECS::VSwitch"}, + "ProductCode": "ecs", + "Name": {"en": "VSwitch", "zh": "交换机"}, + "Properties": [prop("VpcId", "ALIYUN::ECS::VPC")], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::ECS::Instance"}, + "ProductCode": "ecs", + "Name": {"en": "ECS Instance", "zh": "ECS 实例"}, + "Properties": [prop("VSwitchId", "ALIYUN::ECS::VSwitch")], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::VPC::EIP"}, + "ProductCode": "vpc", + "Name": {"en": "EIP", "zh": "弹性公网 IP"}, + "Properties": [], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::VPC::EIPAssociation"}, + "ProductCode": "vpc", + "Name": {"en": "Associate EIP", "zh": "弹性公网 IP 绑定"}, + "MainResourceType": { + "ResourceType": "ROS/ALIYUN::VPC::EIP", + "RefProperty": "ROS/AllocationId", + }, + "Properties": [ + prop("AllocationId", "ALIYUN::VPC::EIP"), + prop("InstanceId", "ALIYUN::ECS::Instance"), + ], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::VPC::NatGateway"}, + "ProductCode": "vpc", + "Name": {"en": "NAT Gateway", "zh": "NAT 网关"}, + "Properties": [prop("VpcId", "ALIYUN::ECS::VPC")], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::VPC::SnatEntry"}, + "ProductCode": "vpc", + "Name": {"en": "SNAT Entry", "zh": "SNAT 条目"}, + "Properties": [prop("SnatTableId", "ALIYUN::VPC::NatGateway")], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::VPC::CommonBandwidthPackage"}, + "ProductCode": "vpc", + "Name": {"en": "Shared Bandwidth Package", "zh": "共享带宽包"}, + "Properties": [], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::VPC::CommonBandwidthPackageIp"}, + "ProductCode": "vpc", + "Name": {"en": "Shared Bandwidth IP", "zh": "共享带宽 IP"}, + "Properties": [ + prop("BandwidthPackageId", "ALIYUN::VPC::CommonBandwidthPackage"), + {"ROS": "Eips", "Type": "Json"}, + ], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::NAS::FileSystem"}, + "ProductCode": "nas", + "Name": {"en": "NAS File System", "zh": "NAS 文件系统"}, + "Properties": [], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::NAS::MountTarget"}, + "ProductCode": "nas", + "Name": {"en": "NAS Mount Target", "zh": "NAS 挂载点"}, + "Properties": [ + prop("FileSystemId", "ALIYUN::NAS::FileSystem"), + prop("VSwitchId", "ALIYUN::ECS::VSwitch"), + ], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::NAS::AccessGroup"}, + "ProductCode": "nas", + "Name": {"en": "NAS Permission Group", "zh": "NAS 权限组"}, + "Properties": [], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::NAS::AccessRule"}, + "ProductCode": "nas", + "Name": {"en": "NAS Permission Rule", "zh": "NAS 权限规则"}, + "Properties": [prop("AccessGroupName", "ALIYUN::NAS::AccessGroup")], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::ECS::RunCommand"}, + "ProductCode": "ecs", + "Name": {"en": "Run Cloud Assistant Command", "zh": "执行云助手命令"}, + "Properties": [prop("InstanceIds", "ALIYUN::ECS::Instance")], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::ESS::ScalingGroup"}, + "ProductCode": "ess", + "Name": {"en": "Scaling Group", "zh": "伸缩组"}, + "Properties": [prop("VSwitchId", "ALIYUN::ECS::VSwitch")], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::ESS::ScalingConfiguration"}, + "ProductCode": "ess", + "Name": {"en": "Scaling Configuration", "zh": "伸缩配置"}, + "Properties": [ + prop("ScalingGroupId", "ALIYUN::ESS::ScalingGroup"), + prop("InstanceId", "ALIYUN::ECS::Instance"), + ], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::ROS::WaitCondition"}, + "ProductCode": "ros", + "Name": {"en": "Wait Condition", "zh": "等待条件"}, + "Properties": [], + }, + ], + ) + + +def _detail(resource_type: str, description: str = "", properties: dict | None = None) -> RosResourceTypeDetail: + return RosResourceTypeDetail( + resource_type=resource_type, + entity_type="Resource", + provider="ROS", + properties=properties or {}, + attributes={}, + description=description, + ) + + +def _snapshot(): + resource_types = [ + "ALIYUN::ECS::VPC", + "ALIYUN::ECS::VSwitch", + "ALIYUN::ECS::Instance", + "ALIYUN::VPC::EIP", + "ALIYUN::VPC::EIPAssociation", + "ALIYUN::VPC::NatGateway", + "ALIYUN::VPC::SnatEntry", + "ALIYUN::VPC::CommonBandwidthPackage", + "ALIYUN::VPC::CommonBandwidthPackageIp", + "ALIYUN::NAS::FileSystem", + "ALIYUN::NAS::MountTarget", + "ALIYUN::NAS::AccessGroup", + "ALIYUN::NAS::AccessRule", + "ALIYUN::ECS::RunCommand", + "ALIYUN::ESS::ScalingGroup", + "ALIYUN::ESS::ScalingConfiguration", + "ALIYUN::ROS::WaitCondition", + "ALIYUN::NEW::ApiOnlyPolicy", + "ALIYUN::VPC::EIPPro", + "ALIYUN::CEN::RouteEntry", + "ALIYUN::CS::ClusterAddons", + "ALIYUN::POLARDB::DBClusterSecurityIP", + ] + return build_resource_inventory_snapshot( + api_resource_types=resource_types, + details_by_type={ + "ALIYUN::VPC::SnatEntry": _detail( + "ALIYUN::VPC::SnatEntry", + "An SNAT entry allows resources in a VPC or vSwitch to access the Internet through a NAT gateway.", + { + "SnatTableId": {"Description": "The ID of the SNAT table."}, + "SnatIp": {"Description": "The public IP address."}, + }, + ), + "ALIYUN::NAS::MountTarget": _detail( + "ALIYUN::NAS::MountTarget", + "A mount target is used by compute resources to mount a NAS file system.", + { + "AccessGroupName": {"Description": "The name of the permission group."}, + "FileSystemId": {"Description": "The ID of the file system."}, + }, + ), + "ALIYUN::VPC::CommonBandwidthPackageIp": _detail( + "ALIYUN::VPC::CommonBandwidthPackageIp", + "Associates EIPs with an Internet shared bandwidth instance.", + { + "BandwidthPackageId": {"Description": "The ID of the Internet Shared Bandwidth instance."}, + "Eips": {"Description": "List of EIPs associated with the shared bandwidth instance."}, + }, + ), + "ALIYUN::ECS::RunCommand": _detail( + "ALIYUN::ECS::RunCommand", + "Runs a Cloud Assistant command on one or more ECS instances.", + { + "CommandContent": {"Description": "The command content."}, + "InstanceIds": {"Description": "The ECS instances on which to run the command."}, + }, + ), + "ALIYUN::ESS::ScalingConfiguration": _detail( + "ALIYUN::ESS::ScalingConfiguration", + "A scaling configuration defines ECS instance settings used by a scaling group.", + { + "ScalingGroupId": {"Description": "The ID of the scaling group."}, + "InstanceId": {"Description": "The source ECS instance used to create the scaling configuration."}, + }, + ), + "ALIYUN::NEW::ApiOnlyPolicy": _detail( + "ALIYUN::NEW::ApiOnlyPolicy", + "A policy resource returned by ListResourceTypes but missing from local meta.", + {"PolicyName": {"Description": "The policy name."}}, + ), + "ALIYUN::VPC::EIPPro": _detail( + "ALIYUN::VPC::EIPPro", + "A pro elastic public IP address that can be associated with resources in a VPC.", + { + "DeletionProtection": {"Description": "Specifies whether to enable deletion protection."}, + }, + ), + "ALIYUN::CEN::RouteEntry": _detail( + "ALIYUN::CEN::RouteEntry", + "A route entry that forwards traffic to a VPC or transit router.", + ), + "ALIYUN::CS::ClusterAddons": _detail( + "ALIYUN::CS::ClusterAddons", + "Configures addons for a Container Service Kubernetes cluster.", + { + "InstallCloudMonitor": {"Description": "Specifies whether to enable the CloudMonitor addon."}, + }, + ), + "ALIYUN::POLARDB::DBClusterSecurityIP": _detail( + "ALIYUN::POLARDB::DBClusterSecurityIP", + "Configures the IP whitelist of a PolarDB cluster.", + ), + }, + meta_repository=_repo(), + fetched_at="2026-06-26T00:00:00Z", + ) + + +def test_extracts_all_eight_rule_candidate_categories() -> None: + candidates = extract_rule_candidates(_snapshot()) + + by_category = {candidate.category for candidate in candidates} + + assert { + "container", + "supplemental_relation", + "display", + "attachment", + "bridge_attachment", + "attachment_edge", + "orchestration_action", + "concept_node", + }.issubset(by_category) + + attachment = next( + candidate + for candidate in candidates + if candidate.category == "attachment" and candidate.resource_type == "ALIYUN::VPC::EIPAssociation" + ) + assert attachment.suggested_config["compact_attachment_marker_types"] == ["ALIYUN::VPC::EIP"] + assert "MainResourceType" in " ".join(attachment.evidence) + + bridge = next( + candidate + for candidate in candidates + if candidate.category == "bridge_attachment" and candidate.resource_type == "ALIYUN::NAS::AccessRule" + ) + assert bridge.target_resource_types == ("ALIYUN::NAS::FileSystem",) + assert "ALIYUN::NAS::MountTarget" in bridge.suggested_config["via_resource_types"] + + attachment_edge = next( + candidate + for candidate in candidates + if candidate.category == "attachment_edge" + and candidate.resource_type == "ALIYUN::VPC::CommonBandwidthPackageIp" + ) + assert attachment_edge.target_resource_types == ( + "ALIYUN::VPC::CommonBandwidthPackage", + "ALIYUN::VPC::EIP", + ) + assert attachment_edge.suggested_config["edge_style"] == "dotted_open" + + +def test_container_candidates_do_not_match_product_or_description_noise() -> None: + candidates = extract_rule_candidates(_snapshot()) + container_types = {candidate.resource_type for candidate in candidates if candidate.category == "container"} + + assert "ALIYUN::ECS::VPC" in container_types + assert "ALIYUN::ECS::VSwitch" in container_types + assert "ALIYUN::VPC::EIPPro" not in container_types + assert "ALIYUN::CEN::RouteEntry" not in container_types + assert "ALIYUN::CS::ClusterAddons" not in container_types + assert "ALIYUN::POLARDB::DBClusterSecurityIP" not in container_types + + +def test_every_api_resource_type_gets_a_decision_with_evidence() -> None: + snapshot = _snapshot() + candidates = extract_rule_candidates(snapshot) + + decisions = build_resource_type_decisions(snapshot, candidates) + + assert set(decisions) == set(snapshot.api_resource_types) + assert decisions["ALIYUN::ECS::VPC"].decision == "container" + assert decisions["ALIYUN::VPC::EIPAssociation"].decision == "attachment" + assert decisions["ALIYUN::ECS::RunCommand"].decision == "orchestration_action" + assert decisions["ALIYUN::ESS::ScalingConfiguration"].decision == "concept_node" + assert decisions["ALIYUN::NEW::ApiOnlyPolicy"].decision == "needs_review" + assert decisions["ALIYUN::VPC::EIPPro"].decision == "needs_review" + assert decisions["ALIYUN::NEW::ApiOnlyPolicy"].evidence + + +def test_renders_markdown_report_grouped_by_category_and_product() -> None: + snapshot = _snapshot() + candidates = extract_rule_candidates(snapshot) + decisions = build_resource_type_decisions(snapshot, candidates) + + markdown = render_rule_candidate_report_markdown(snapshot, candidates, decisions) + + assert "# ROS 架构图规则候选报告" in markdown + assert "| API resource types | 22 |" in markdown + assert "## Candidate Categories" in markdown + assert "### attachment" in markdown + assert "`ALIYUN::VPC::EIPAssociation`" in markdown + assert "## Decisions by Product" in markdown + assert "### `vpc`" in markdown + assert "`ALIYUN::VPC::CommonBandwidthPackageIp` | `attachment_edge`" in markdown diff --git a/tests/pipeline/engine/test_architecture_rule_drafts.py b/tests/pipeline/engine/test_architecture_rule_drafts.py new file mode 100644 index 00000000..cad98e89 --- /dev/null +++ b/tests/pipeline/engine/test_architecture_rule_drafts.py @@ -0,0 +1,691 @@ +from __future__ import annotations + +import json + +from iac_code.pipeline.engine.architecture_meta import ArchitectureMetaRepository +from iac_code.pipeline.engine.architecture_resource_inventory import ( + RosResourceTypeDetail, + build_resource_inventory_snapshot, +) +from iac_code.pipeline.engine.architecture_rule_drafts import ( + apply_reviewed_draft_patches, + parse_draft_rules_response, + render_draft_review_report_markdown, + review_valid_draft_rules, + validate_draft_rules, +) +from iac_code.pipeline.engine.architecture_rule_facts import build_resource_rule_facts + + +def _repo() -> ArchitectureMetaRepository: + def prop(name: str, target: str) -> dict: + return {"ROS": name, "RelatedTo": [{"ResourceType": f"ROS/{target}"}]} + + return ArchitectureMetaRepository.from_raw( + categories=[{"CategoryCode": "network", "ProductCodes": ["ecs", "vpc", "nas", "ess"]}], + products=[ + {"ProductCode": "ecs", "Name": {"en": "ECS", "zh": "云服务器"}, "RelevantCodes": {"ROS": "ECS"}}, + {"ProductCode": "vpc", "Name": {"en": "VPC", "zh": "专有网络"}, "RelevantCodes": {"ROS": "VPC"}}, + {"ProductCode": "nas", "Name": {"en": "NAS", "zh": "文件存储"}, "RelevantCodes": {"ROS": "NAS"}}, + {"ProductCode": "ess", "Name": {"en": "ESS", "zh": "弹性伸缩"}, "RelevantCodes": {"ROS": "ESS"}}, + ], + config=[ + { + "ResourceType": {"ROS": "ROS/ALIYUN::ECS::VPC"}, + "ProductCode": "ecs", + "Name": {"en": "VPC", "zh": "专有网络 VPC"}, + "Properties": [], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::ECS::VSwitch"}, + "ProductCode": "ecs", + "Name": {"en": "VSwitch", "zh": "交换机"}, + "Properties": [prop("VpcId", "ALIYUN::ECS::VPC")], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::ECS::SecurityGroup"}, + "ProductCode": "ecs", + "Name": {"en": "Security Group", "zh": "安全组"}, + "Properties": [prop("VpcId", "ALIYUN::ECS::VPC")], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::ECS::Instance"}, + "ProductCode": "ecs", + "Name": {"en": "ECS Instance", "zh": "ECS 实例"}, + "Properties": [ + prop("VSwitchId", "ALIYUN::ECS::VSwitch"), + prop("SecurityGroupId", "ALIYUN::ECS::SecurityGroup"), + ], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::VPC::NatGateway"}, + "ProductCode": "vpc", + "Name": {"en": "NAT Gateway", "zh": "NAT 网关"}, + "Properties": [prop("VpcId", "ALIYUN::ECS::VPC")], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::VPC::SnatEntry"}, + "ProductCode": "vpc", + "Name": {"en": "SNAT Entry", "zh": "SNAT 条目"}, + "Properties": [prop("SnatTableId", "ALIYUN::VPC::NatGateway")], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::VPC::CommonBandwidthPackage"}, + "ProductCode": "vpc", + "Name": {"en": "Shared Bandwidth Package", "zh": "共享带宽包"}, + "Properties": [], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::VPC::EIP"}, + "ProductCode": "vpc", + "Name": {"en": "EIP", "zh": "弹性公网 IP"}, + "Properties": [], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::VPC::CommonBandwidthPackageIp"}, + "ProductCode": "vpc", + "Name": {"en": "Shared Bandwidth IP", "zh": "共享带宽 IP"}, + "Properties": [ + prop("BandwidthPackageId", "ALIYUN::VPC::CommonBandwidthPackage"), + prop("Eips", "ALIYUN::VPC::EIP"), + ], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::NAS::FileSystem"}, + "ProductCode": "nas", + "Name": {"en": "NAS File System", "zh": "NAS 文件系统"}, + "Properties": [], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::NAS::MountTarget"}, + "ProductCode": "nas", + "Name": {"en": "NAS Mount Target", "zh": "NAS 挂载点"}, + "Properties": [prop("FileSystemId", "ALIYUN::NAS::FileSystem")], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::ECS::RunCommand"}, + "ProductCode": "ecs", + "Name": {"en": "Run Command", "zh": "执行命令"}, + "Properties": [prop("InstanceIds", "ALIYUN::ECS::Instance")], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::ESS::ScalingConfiguration"}, + "ProductCode": "ess", + "Name": {"en": "Scaling Configuration", "zh": "伸缩配置"}, + "Properties": [ + prop("ScalingGroupId", "ALIYUN::ESS::ScalingGroup"), + prop("InstanceId", "ALIYUN::ECS::Instance"), + ], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::ESS::ScalingGroup"}, + "ProductCode": "ess", + "Name": {"en": "Scaling Group", "zh": "伸缩组"}, + "Properties": [prop("VSwitchId", "ALIYUN::ECS::VSwitch")], + }, + ], + ) + + +def _detail(resource_type: str, description: str = "", properties: dict | None = None) -> RosResourceTypeDetail: + return RosResourceTypeDetail( + resource_type=resource_type, + entity_type="Resource", + provider="ROS", + properties=properties or {}, + attributes={}, + description=description, + ) + + +def _facts(): + snapshot = build_resource_inventory_snapshot( + api_resource_types=[ + "ALIYUN::ECS::VPC", + "ALIYUN::ECS::VSwitch", + "ALIYUN::ECS::SecurityGroup", + "ALIYUN::ECS::Instance", + "ALIYUN::VPC::NatGateway", + "ALIYUN::VPC::SnatEntry", + "ALIYUN::VPC::CommonBandwidthPackage", + "ALIYUN::VPC::EIP", + "ALIYUN::VPC::CommonBandwidthPackageIp", + "ALIYUN::NAS::FileSystem", + "ALIYUN::NAS::MountTarget", + "ALIYUN::ECS::RunCommand", + "ALIYUN::ESS::ScalingConfiguration", + "ALIYUN::ESS::ScalingGroup", + ], + details_by_type={ + "ALIYUN::VPC::SnatEntry": _detail( + "ALIYUN::VPC::SnatEntry", + "SNAT entries configure internet access through a NAT gateway.", + {"SnatTableId": {"Description": "The ID of the SNAT table."}}, + ), + "ALIYUN::VPC::CommonBandwidthPackageIp": _detail( + "ALIYUN::VPC::CommonBandwidthPackageIp", + "Associates EIPs with a shared bandwidth package.", + ), + "ALIYUN::NAS::MountTarget": _detail( + "ALIYUN::NAS::MountTarget", + "Mount point used by compute resources to access a NAS file system.", + ), + "ALIYUN::ECS::RunCommand": _detail( + "ALIYUN::ECS::RunCommand", + "Runs a Cloud Assistant command on ECS instances.", + {"CommandContent": {"Description": "The command content."}}, + ), + "ALIYUN::ESS::ScalingConfiguration": _detail( + "ALIYUN::ESS::ScalingConfiguration", + "Defines ECS instance settings for a scaling group.", + ), + }, + meta_repository=_repo(), + ) + return build_resource_rule_facts(snapshot) + + +def _draft_payload() -> str: + return json.dumps( + { + "draft_rules": [ + { + "resource_type": "ALIYUN::VPC::SnatEntry", + "classification": "attachment", + "target_resource_types": ["ALIYUN::VPC::NatGateway"], + "property_names": ["SnatTableId"], + "label": {"zh": "SNAT条目", "en": "SNAT entry"}, + "edge_label": None, + "confidence": 0.91, + "evidence": ["Description says SNAT entries configure internet access through NAT Gateway."], + "suggested_architecture_rules_patch": { + "compact_child_attachments": [ + { + "resource_types": ["ALIYUN::VPC::SnatEntry"], + "target_properties": ["SnatTableId"], + "target_types": ["ALIYUN::VPC::NatGateway"], + "label": {"zh": "SNAT条目", "en": "SNAT entry"}, + } + ] + }, + }, + { + "resource_type": "ALIYUN::VPC::CommonBandwidthPackageIp", + "classification": "attachment_edge", + "target_resource_types": [ + "ALIYUN::VPC::CommonBandwidthPackage", + "ALIYUN::VPC::EIP", + ], + "property_names": ["BandwidthPackageId", "Eips"], + "label": {"zh": "共享带宽IP", "en": "shared bandwidth IP"}, + "edge_label": {"zh": "提供公网带宽", "en": "provides public bandwidth"}, + "confidence": 0.86, + "evidence": ["The resource associates EIPs with a shared bandwidth package."], + "suggested_architecture_rules_patch": { + "compact_attachment_edges": [ + { + "resource_types": ["ALIYUN::VPC::CommonBandwidthPackageIp"], + "source_properties": ["BandwidthPackageId"], + "marker_properties": ["Eips"], + "source_types": ["ALIYUN::VPC::CommonBandwidthPackage"], + "marker_types": ["ALIYUN::VPC::EIP"], + "edge_style": "dotted_open", + "edge_label": {"zh": "提供公网带宽", "en": "provides public bandwidth"}, + } + ] + }, + }, + { + "resource_type": "ALIYUN::ECS::RunCommand", + "classification": "orchestration_action", + "target_resource_types": ["ALIYUN::ECS::Instance"], + "property_names": ["InstanceIds", "CommandContent"], + "label": {"zh": "云助手执行", "en": "Cloud Assistant execution"}, + "edge_label": {"zh": "执行命令", "en": "runs command"}, + "confidence": 0.88, + "evidence": ["Description says it runs a command on ECS instances."], + "suggested_architecture_rules_patch": { + "compact_orchestration_actions": [ + { + "resource_types": ["ALIYUN::ECS::RunCommand"], + "command_properties": ["CommandContent"], + "target_properties": ["InstanceIds"], + "evidence_properties": ["CommandContent"], + } + ] + }, + }, + { + "resource_type": "ALIYUN::NAS::MountTarget", + "classification": "bridge_attachment", + "target_resource_types": ["ALIYUN::NAS::FileSystem"], + "property_names": ["FileSystemId"], + "label": {"zh": "NAS挂载点", "en": "NAS mount target"}, + "edge_label": None, + "confidence": 0.83, + "evidence": ["Mount target bridges compute access to the NAS file system."], + "suggested_architecture_rules_patch": { + "compact_bridge_attachments": [ + { + "resource_types": ["ALIYUN::NAS::MountTarget"], + "source_properties": [], + "via_resource_types": ["ALIYUN::NAS::MountTarget"], + "via_source_properties": ["FileSystemId"], + "via_target_properties": ["FileSystemId"], + "target_types": ["ALIYUN::NAS::FileSystem"], + "label": {"zh": "NAS挂载点", "en": "NAS mount target"}, + } + ] + }, + }, + { + "resource_type": "ALIYUN::ESS::ScalingConfiguration", + "classification": "concept_node", + "target_resource_types": [ + "ALIYUN::ESS::ScalingGroup", + "ALIYUN::ECS::Instance", + ], + "property_names": ["ScalingGroupId", "InstanceId"], + "label": {"zh": "伸缩 ECS 实例", "en": "Scaled ECS instances"}, + "edge_label": {"zh": "伸缩配置", "en": "scaling config"}, + "confidence": 0.9, + "evidence": ["Scaling configuration links a scaling group and source ECS instance."], + "suggested_architecture_rules_patch": { + "compact_concept_nodes": [ + { + "via_resource_types": ["ALIYUN::ESS::ScalingConfiguration"], + "controller_property": "ScalingGroupId", + "source_property": "InstanceId", + "id_suffix": "ScaledEcs", + "resource_type": "CONCEPT::ESS::ScaledECS", + "label": {"zh": "伸缩 ECS 实例", "en": "Scaled ECS instances"}, + } + ] + }, + }, + { + "resource_type": "ALIYUN::ECS::VPC", + "classification": "container", + "target_resource_types": [], + "property_names": [], + "label": {"zh": "专有网络 VPC", "en": "VPC"}, + "edge_label": None, + "confidence": 0.94, + "evidence": ["VPC is a network boundary."], + "suggested_architecture_rules_patch": { + "network_layer_types": ["ALIYUN::ECS::VPC"], + "containment_layer_types": {"vpc": ["ALIYUN::ECS::VPC"]}, + }, + }, + { + "resource_type": "ALIYUN::ECS::SecurityGroup", + "classification": "attachment", + "target_resource_types": ["ALIYUN::ECS::Instance"], + "property_names": ["NotAProperty"], + "label": {"zh": "安全组", "en": "security group"}, + "edge_label": None, + "confidence": 0.9, + "evidence": ["Invalid property should be rejected."], + "suggested_architecture_rules_patch": { + "compact_child_attachments": [ + { + "resource_types": ["ALIYUN::ECS::SecurityGroup"], + "target_properties": ["NotAProperty"], + "target_types": ["ALIYUN::ECS::Instance"], + "label": {"zh": "安全组", "en": "security group"}, + } + ] + }, + }, + { + "resource_type": "ALIYUN::ECS::Instance", + "classification": "attachment_edge", + "target_resource_types": ["ALIYUN::ECS::Instance"], + "property_names": ["VSwitchId"], + "label": {"zh": "错误实线", "en": "bad solid"}, + "edge_label": {"zh": "业务访问", "en": "traffic"}, + "confidence": 0.92, + "evidence": ["Attachment edges must not become solid traffic arrows."], + "suggested_architecture_rules_patch": { + "compact_attachment_edges": [ + { + "resource_types": ["ALIYUN::ECS::Instance"], + "source_properties": ["VSwitchId"], + "marker_properties": ["VSwitchId"], + "source_types": ["ALIYUN::ECS::VSwitch"], + "marker_types": ["ALIYUN::ECS::Instance"], + "edge_style": "solid_arrow", + "edge_label": {"zh": "业务访问", "en": "traffic"}, + } + ] + }, + }, + ] + }, + ensure_ascii=False, + ) + + +def test_parse_validate_and_review_draft_rules_before_applying_patches() -> None: + facts = _facts() + drafts = parse_draft_rules_response(_draft_payload()) + + validated = validate_draft_rules(drafts, facts) + reviewed = review_valid_draft_rules(validated) + + accepted = [decision for decision in reviewed if decision.accepted] + rejected = [decision for decision in reviewed if not decision.accepted] + + assert len(drafts) == 8 + assert {decision.draft.resource_type for decision in accepted} == { + "ALIYUN::VPC::SnatEntry", + "ALIYUN::VPC::CommonBandwidthPackageIp", + "ALIYUN::ECS::RunCommand", + "ALIYUN::NAS::MountTarget", + "ALIYUN::ESS::ScalingConfiguration", + "ALIYUN::ECS::VPC", + } + assert any("unknown property" in " ".join(decision.reasons) for decision in rejected) + assert any("solid" in " ".join(decision.reasons) for decision in rejected) + + raw_rules: dict = { + "network_layer_types": [], + "containment_layer_types": {}, + "compact_child_attachments": [], + "compact_bridge_attachments": [], + "compact_attachment_edges": [], + "compact_orchestration_actions": [], + "compact_concept_nodes": [], + } + updated = apply_reviewed_draft_patches(raw_rules, reviewed) + + assert updated["network_layer_types"] == ["ALIYUN::ECS::VPC"] + assert updated["containment_layer_types"] == {"vpc": ["ALIYUN::ECS::VPC"]} + assert updated["compact_child_attachments"][0]["resource_types"] == ["ALIYUN::VPC::SnatEntry"] + assert updated["compact_attachment_edges"][0]["edge_style"] == "dotted_open" + assert updated["compact_orchestration_actions"][0]["resource_types"] == ["ALIYUN::ECS::RunCommand"] + assert updated["compact_concept_nodes"][0]["resource_type"] == "CONCEPT::ESS::ScaledECS" + assert all( + item.get("resource_types") != ["ALIYUN::ECS::SecurityGroup"] for item in updated["compact_child_attachments"] + ) + + updated_again = apply_reviewed_draft_patches(updated, reviewed) + assert updated_again["compact_child_attachments"] == updated["compact_child_attachments"] + assert updated_again["compact_orchestration_actions"] == updated["compact_orchestration_actions"] + + report = render_draft_review_report_markdown(reviewed) + assert "| Draft rules | 8 |" in report + assert "| Accepted | 6 |" in report + assert "| Rejected | 2 |" in report + assert "## By Classification" in report + + +def test_rejects_draft_with_unknown_target_or_patch_key() -> None: + facts = _facts() + drafts = parse_draft_rules_response( + json.dumps( + { + "draft_rules": [ + { + "resource_type": "ALIYUN::VPC::SnatEntry", + "classification": "attachment", + "target_resource_types": ["ALIYUN::NOT::Real"], + "property_names": ["SnatTableId"], + "label": "SNAT entry", + "edge_label": None, + "confidence": 0.9, + "evidence": ["bad target"], + "suggested_architecture_rules_patch": {"compact_child_attachments": []}, + }, + { + "resource_type": "ALIYUN::VPC::SnatEntry", + "classification": "attachment", + "target_resource_types": ["ALIYUN::VPC::NatGateway"], + "property_names": ["SnatTableId"], + "label": "SNAT entry", + "edge_label": None, + "confidence": 0.9, + "evidence": ["bad patch key"], + "suggested_architecture_rules_patch": {"made_up_key": []}, + }, + ] + } + ) + ) + + reviewed = review_valid_draft_rules(validate_draft_rules(drafts, facts)) + + assert [decision.accepted for decision in reviewed] == [False, False] + assert "unknown target resource type" in " ".join(reviewed[0].reasons) + assert "unsupported patch key" in " ".join(reviewed[1].reasons) + + +def test_rejects_nested_patch_with_unknown_resource_type_or_property() -> None: + facts = _facts() + drafts = parse_draft_rules_response( + json.dumps( + { + "draft_rules": [ + { + "resource_type": "ALIYUN::VPC::SnatEntry", + "classification": "attachment", + "target_resource_types": ["ALIYUN::VPC::NatGateway"], + "property_names": ["SnatTableId"], + "label": "SNAT entry", + "edge_label": None, + "confidence": 0.9, + "evidence": ["bad nested patch"], + "suggested_architecture_rules_patch": { + "compact_child_attachments": [ + { + "resource_types": ["ALIYUN::NOT::Real"], + "target_properties": ["NotAProperty"], + "target_types": ["ALIYUN::VPC::NatGateway"], + "label": "SNAT entry", + } + ] + }, + } + ] + } + ) + ) + + reviewed = review_valid_draft_rules(validate_draft_rules(drafts, facts)) + + assert reviewed[0].accepted is False + reasons = " ".join(reviewed[0].reasons) + assert "unknown patch resource type" in reasons + assert "unknown patch property" in reasons + + +def test_attachment_edge_draft_can_use_edge_label_without_node_label() -> None: + facts = _facts() + drafts = parse_draft_rules_response( + json.dumps( + { + "draft_rules": [ + { + "resource_type": "ALIYUN::VPC::CommonBandwidthPackageIp", + "classification": "attachment_edge", + "target_resource_types": [ + "ALIYUN::VPC::CommonBandwidthPackage", + "ALIYUN::VPC::EIP", + ], + "property_names": ["BandwidthPackageId", "Eips"], + "label": None, + "edge_label": {"zh": "提供公网带宽", "en": "provides bandwidth"}, + "confidence": 0.9, + "evidence": ["The resource associates EIPs with a shared bandwidth package."], + "suggested_architecture_rules_patch": { + "compact_attachment_edges": [ + { + "resource_types": ["ALIYUN::VPC::CommonBandwidthPackageIp"], + "source_properties": ["BandwidthPackageId"], + "marker_properties": ["Eips"], + "source_types": ["ALIYUN::VPC::CommonBandwidthPackage"], + "marker_types": ["ALIYUN::VPC::EIP"], + "edge_style": "dotted_open", + "edge_label": {"zh": "提供公网带宽", "en": "provides bandwidth"}, + } + ] + }, + } + ] + } + ) + ) + + reviewed = review_valid_draft_rules(validate_draft_rules(drafts, facts)) + + assert reviewed[0].accepted is True + + +def test_bridge_attachment_requires_via_resource_types() -> None: + facts = _facts() + drafts = parse_draft_rules_response( + json.dumps( + { + "draft_rules": [ + { + "resource_type": "ALIYUN::NAS::MountTarget", + "classification": "bridge_attachment", + "target_resource_types": ["ALIYUN::NAS::FileSystem"], + "property_names": ["FileSystemId"], + "label": "NAS mount target", + "edge_label": None, + "confidence": 0.9, + "evidence": ["Association resource without a via resource cannot fold in renderer."], + "suggested_architecture_rules_patch": { + "compact_bridge_attachments": [ + { + "resource_types": ["ALIYUN::NAS::MountTarget"], + "source_properties": ["FileSystemId"], + "via_resource_types": [], + "via_source_properties": [], + "via_target_properties": [], + "target_types": ["ALIYUN::NAS::FileSystem"], + "label": "NAS mount target", + } + ] + }, + } + ] + } + ) + ) + + reviewed = review_valid_draft_rules(validate_draft_rules(drafts, facts)) + + assert reviewed[0].accepted is False + assert "via_resource_types" in " ".join(reviewed[0].reasons) + + +def test_apply_localizes_string_patch_labels_from_resource_facts() -> None: + facts = _facts() + drafts = parse_draft_rules_response( + json.dumps( + { + "draft_rules": [ + { + "resource_type": "ALIYUN::VPC::SnatEntry", + "classification": "attachment", + "target_resource_types": ["ALIYUN::VPC::NatGateway"], + "property_names": ["SnatTableId"], + "label": "SNAT entry", + "edge_label": None, + "confidence": 0.9, + "evidence": ["SNAT entry configures NAT gateway."], + "suggested_architecture_rules_patch": { + "compact_child_attachments": [ + { + "resource_types": ["ALIYUN::VPC::SnatEntry"], + "target_properties": ["SnatTableId"], + "target_types": ["ALIYUN::VPC::NatGateway"], + "label": "SNAT entry", + } + ] + }, + } + ] + } + ) + ) + reviewed = review_valid_draft_rules(validate_draft_rules(drafts, facts)) + + updated = apply_reviewed_draft_patches({"compact_child_attachments": []}, reviewed, facts=facts) + + assert updated["compact_child_attachments"][0]["label"] == { + "zh": "SNAT 条目", + "en": "SNAT entry", + } + + +def test_apply_skips_semantic_duplicate_resource_type_rules() -> None: + facts = _facts() + drafts = parse_draft_rules_response( + json.dumps( + { + "draft_rules": [ + { + "resource_type": "ALIYUN::VPC::SnatEntry", + "classification": "attachment", + "target_resource_types": ["ALIYUN::VPC::NatGateway"], + "property_names": ["SnatTableId"], + "label": "SNAT config", + "edge_label": None, + "confidence": 0.9, + "evidence": ["same semantic resource type with a different label"], + "suggested_architecture_rules_patch": { + "compact_child_attachments": [ + { + "resource_types": ["ALIYUN::VPC::SnatEntry"], + "target_properties": ["SnatTableId"], + "target_types": ["ALIYUN::VPC::NatGateway"], + "label": "SNAT config", + } + ] + }, + } + ] + } + ) + ) + reviewed = review_valid_draft_rules(validate_draft_rules(drafts, facts)) + raw_rules = { + "compact_child_attachments": [ + { + "resource_types": ["ALIYUN::VPC::SnatEntry"], + "target_properties": ["SnatTableId"], + "target_types": ["ALIYUN::VPC::NatGateway"], + "label": "SNAT entry", + } + ] + } + + updated = apply_reviewed_draft_patches(raw_rules, reviewed) + + assert updated["compact_child_attachments"] == raw_rules["compact_child_attachments"] + + +def test_parse_accepts_top_level_list_from_llm() -> None: + drafts = parse_draft_rules_response( + json.dumps( + [ + { + "resource_type": "ALIYUN::VPC::SnatEntry", + "classification": "attachment", + "target_resource_types": ["ALIYUN::VPC::NatGateway"], + "property_names": ["SnatTableId"], + "label": "SNAT entry", + "edge_label": None, + "confidence": 0.9, + "evidence": ["LLM returned a top-level list."], + "suggested_architecture_rules_patch": {"compact_child_attachments": []}, + } + ] + ) + ) + + assert len(drafts) == 1 + assert drafts[0].resource_type == "ALIYUN::VPC::SnatEntry" diff --git a/tests/pipeline/engine/test_architecture_rule_facts.py b/tests/pipeline/engine/test_architecture_rule_facts.py new file mode 100644 index 00000000..74dd3a98 --- /dev/null +++ b/tests/pipeline/engine/test_architecture_rule_facts.py @@ -0,0 +1,250 @@ +from __future__ import annotations + +from iac_code.pipeline.engine.architecture_meta import ArchitectureMetaRepository +from iac_code.pipeline.engine.architecture_resource_inventory import ( + RosResourceTypeDetail, + build_resource_inventory_snapshot, +) +from iac_code.pipeline.engine.architecture_rule_facts import build_resource_rule_facts +from iac_code.pipeline.engine.architecture_rules import ArchitectureRules + + +def _repo() -> ArchitectureMetaRepository: + def prop(name: str, target: str) -> dict: + return {"ROS": name, "Type": "String", "RelatedTo": [{"ResourceType": f"ROS/{target}"}]} + + return ArchitectureMetaRepository.from_raw( + categories=[ + {"CategoryCode": "network", "ProductCodes": ["ecs", "vpc"]}, + {"CategoryCode": "database", "ProductCodes": ["polardb"]}, + {"CategoryCode": "storage", "ProductCodes": ["nas"]}, + ], + products=[ + {"ProductCode": "ecs", "Name": {"en": "ECS", "zh": "云服务器"}, "RelevantCodes": {"ROS": "ECS"}}, + {"ProductCode": "vpc", "Name": {"en": "VPC", "zh": "专有网络"}, "RelevantCodes": {"ROS": "VPC"}}, + {"ProductCode": "nas", "Name": {"en": "NAS", "zh": "文件存储"}, "RelevantCodes": {"ROS": "NAS"}}, + { + "ProductCode": "polardb", + "Name": {"en": "PolarDB", "zh": "云原生数据库"}, + "RelevantCodes": {"ROS": "POLARDB"}, + }, + ], + config=[ + { + "ResourceType": {"ROS": "ROS/ALIYUN::ECS::VPC"}, + "ProductCode": "ecs", + "Name": {"en": "VPC", "zh": "专有网络 VPC"}, + "Properties": [], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::ECS::VSwitch"}, + "ProductCode": "ecs", + "Name": {"en": "VSwitch", "zh": "交换机"}, + "Properties": [prop("VpcId", "ALIYUN::ECS::VPC")], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::ECS::Instance"}, + "ProductCode": "ecs", + "Name": {"en": "ECS Instance", "zh": "ECS 实例"}, + "Properties": [prop("VSwitchId", "ALIYUN::ECS::VSwitch")], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::VPC::EIP"}, + "ProductCode": "vpc", + "Name": {"en": "EIP", "zh": "弹性公网 IP"}, + "Properties": [], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::VPC::EIPAssociation"}, + "ProductCode": "vpc", + "Name": {"en": "Associate EIP", "zh": "弹性公网 IP 绑定"}, + "MainResourceType": { + "ResourceType": "ROS/ALIYUN::VPC::EIP", + "RefProperty": "ROS/AllocationId", + }, + "Properties": [ + prop("AllocationId", "ALIYUN::VPC::EIP"), + prop("InstanceId", "ALIYUN::ECS::Instance"), + ], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::NAS::FileSystem"}, + "ProductCode": "nas", + "Name": {"en": "NAS File System", "zh": "NAS 文件系统"}, + "Properties": [], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::NAS::MountTarget"}, + "ProductCode": "nas", + "Name": {"en": "NAS Mount Target", "zh": "NAS 挂载点"}, + "Properties": [ + prop("AccessGroupName", "ALIYUN::NAS::AccessGroup"), + prop("FileSystemId", "ALIYUN::NAS::FileSystem"), + prop("VSwitchId", "ALIYUN::ECS::VSwitch"), + ], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::NAS::AccessGroup"}, + "ProductCode": "nas", + "Name": {"en": "NAS Permission Group", "zh": "NAS 权限组"}, + "Properties": [], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::NAS::AccessRule"}, + "ProductCode": "nas", + "Name": {"en": "NAS Permission Rule", "zh": "NAS 权限规则"}, + "Properties": [prop("AccessGroupName", "ALIYUN::NAS::AccessGroup")], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::ECS::RunCommand"}, + "ProductCode": "ecs", + "Name": {"en": "Run Cloud Assistant Command", "zh": "执行云助手命令"}, + "Properties": [prop("InstanceIds", "ALIYUN::ECS::Instance")], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::ESS::ScalingGroup"}, + "ProductCode": "ecs", + "Name": {"en": "Scaling Group", "zh": "伸缩组"}, + "Properties": [prop("VSwitchId", "ALIYUN::ECS::VSwitch")], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::ESS::ScalingConfiguration"}, + "ProductCode": "ecs", + "Name": {"en": "Scaling Configuration", "zh": "伸缩配置"}, + "Properties": [ + prop("ScalingGroupId", "ALIYUN::ESS::ScalingGroup"), + prop("InstanceId", "ALIYUN::ECS::Instance"), + ], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::POLARDB::DBClusterSecurityIP"}, + "ProductCode": "polardb", + "Name": {"en": "PolarDB whitelist", "zh": "PolarDB 白名单"}, + "Properties": [prop("DBClusterId", "ALIYUN::POLARDB::DBCluster")], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::POLARDB::DBCluster"}, + "ProductCode": "polardb", + "Name": {"en": "PolarDB Cluster", "zh": "PolarDB 集群"}, + "Properties": [], + }, + ], + ) + + +def _detail(resource_type: str, description: str = "", properties: dict | None = None) -> RosResourceTypeDetail: + return RosResourceTypeDetail( + resource_type=resource_type, + entity_type="Resource", + provider="ROS", + properties=properties or {}, + attributes={}, + description=description, + ) + + +def _snapshot(): + resource_types = [ + "ALIYUN::ECS::VPC", + "ALIYUN::ECS::VSwitch", + "ALIYUN::ECS::Instance", + "ALIYUN::VPC::EIP", + "ALIYUN::VPC::EIPAssociation", + "ALIYUN::NAS::FileSystem", + "ALIYUN::NAS::MountTarget", + "ALIYUN::NAS::AccessGroup", + "ALIYUN::NAS::AccessRule", + "ALIYUN::ECS::RunCommand", + "ALIYUN::ESS::ScalingGroup", + "ALIYUN::ESS::ScalingConfiguration", + "ALIYUN::POLARDB::DBCluster", + "ALIYUN::POLARDB::DBClusterSecurityIP", + ] + return build_resource_inventory_snapshot( + api_resource_types=resource_types, + details_by_type={ + "ALIYUN::VPC::EIPAssociation": _detail( + "ALIYUN::VPC::EIPAssociation", + "Associates an elastic IP address with an ECS instance or SLB instance.", + { + "AllocationId": {"Type": "string", "Required": True, "Description": "The ID of the EIP."}, + "InstanceId": { + "Type": "string", + "Required": True, + "Description": "The ID of the instance to associate.", + }, + }, + ), + "ALIYUN::NAS::AccessRule": _detail( + "ALIYUN::NAS::AccessRule", + "Configures an access rule for a NAS permission group.", + {"AccessGroupName": {"Description": "The permission group name."}}, + ), + "ALIYUN::ECS::RunCommand": _detail( + "ALIYUN::ECS::RunCommand", + "Runs a Cloud Assistant command on ECS instances.", + { + "CommandContent": {"Description": "The command content."}, + "InstanceIds": {"Description": "The ECS instances on which to run the command."}, + }, + ), + "ALIYUN::ESS::ScalingConfiguration": _detail( + "ALIYUN::ESS::ScalingConfiguration", + "Defines ECS settings used by a scaling group.", + { + "ScalingGroupId": {"Description": "The scaling group ID."}, + "InstanceId": {"Description": "The source ECS instance."}, + }, + ), + "ALIYUN::POLARDB::DBClusterSecurityIP": _detail( + "ALIYUN::POLARDB::DBClusterSecurityIP", + "Configures a whitelist for a PolarDB cluster.", + ), + }, + meta_repository=_repo(), + fetched_at="2026-06-27T00:00:00Z", + ) + + +def test_builds_resource_facts_and_signals_without_final_decisions() -> None: + bundle = build_resource_rule_facts(_snapshot(), ArchitectureRules.load_default()) + + payload = bundle.to_dict() + + assert set(payload) == {"summary", "resource_facts", "rule_signals"} + assert "candidates" not in payload + assert "decisions" not in payload + assert payload["summary"]["api_resource_types"] == 14 + assert payload["summary"]["resource_facts"] == 14 + assert payload["summary"]["rule_signals"] >= 6 + + eip_fact = next( + fact for fact in payload["resource_facts"] if fact["resource_type"] == "ALIYUN::VPC::EIPAssociation" + ) + assert eip_fact["main_resource_type"] == { + "resource_type": "ALIYUN::VPC::EIP", + "ref_property": "AllocationId", + } + assert eip_fact["related_properties"]["AllocationId"] == ["ALIYUN::VPC::EIP"] + assert eip_fact["properties"]["InstanceId"]["description"] == "The ID of the instance to associate." + assert "fixed_rule_hits" in eip_fact + + signal_categories = {signal["category"] for signal in payload["rule_signals"]} + assert { + "attachment", + "bridge_attachment", + "orchestration_action", + "concept_node", + "container", + }.issubset(signal_categories) + assert all("decision" not in signal for signal in payload["rule_signals"]) + + +def test_container_signal_does_not_classify_whitelist_noise_as_container() -> None: + bundle = build_resource_rule_facts(_snapshot(), ArchitectureRules.load_default()) + + container_types = {signal.resource_type for signal in bundle.rule_signals if signal.category == "container"} + + assert "ALIYUN::ECS::VPC" in container_types + assert "ALIYUN::ECS::VSwitch" in container_types + assert "ALIYUN::POLARDB::DBClusterSecurityIP" not in container_types diff --git a/tests/pipeline/engine/test_architecture_rules.py b/tests/pipeline/engine/test_architecture_rules.py new file mode 100644 index 00000000..217f4559 --- /dev/null +++ b/tests/pipeline/engine/test_architecture_rules.py @@ -0,0 +1,172 @@ +from iac_code.pipeline.engine.architecture_rules import ArchitectureRules + + +def test_loads_fixed_architecture_rules(): + rules = ArchitectureRules.load_default() + + assert "ALIYUN::ECS::VPC" in rules.network_layer_types + assert rules.fallback_related_properties["VpcId"] == ("ALIYUN::ECS::VPC",) + assert rules.edge_styles.auxiliary_relation == "solid_arrow" + assert rules.edge_styles.direct_relation == "dotted_open" + assert rules.edge_operator("solid_arrow") == "-->" + assert rules.edge_operator("dotted_open") == "-.-" + assert rules.edge_operator("dotted_arrow") == "-.->" + assert rules.compact_flatten_layer_roles == frozenset({"security_group"}) + assert rules.containment_layer_types["cloud_network"] == ("ALIYUN::CEN::CenInstance",) + + +def test_loads_compact_concept_node_rules(): + rules = ArchitectureRules.load_default() + concept = rules.compact_concept_nodes[0] + + assert concept.via_resource_types == frozenset({"ALIYUN::ESS::ScalingConfiguration"}) + assert concept.controller_property == "ScalingGroupId" + assert concept.source_property == "InstanceId" + assert concept.id_suffix == "ScaledEcs" + assert concept.resource_type == "CONCEPT::ESS::ScaledECS" + assert concept.label == {"en": "Scaled ECS instances", "zh": "伸缩 ECS 实例"} + assert concept.controller_edge is not None + assert concept.controller_edge.style == "solid_arrow" + assert concept.controller_edge.label == {"en": "scales", "zh": "弹性伸缩"} + assert concept.controller_edge.target == "concept" + assert concept.source_edge is not None + assert concept.source_edge.style == "dotted_arrow" + assert concept.source_edge.label == {"en": "scaling config", "zh": "伸缩配置"} + assert concept.source_edge.target == "controller" + assert concept.group is not None + assert concept.group.id_suffix == "ApplicationGroup" + assert concept.group.resource_type == "CONCEPT::Application::ServerGroup" + assert concept.group.label == {"en": "Application server group", "zh": "应用服务组"} + assert concept.group.members == ("source", "concept") + assert concept.group.rewrite_edge_kinds == ("traffic", "dependency", "inferred") + + +def test_loads_compact_relation_fold_rules(): + rules = ArchitectureRules.load_default() + folds = {tuple(fold.via_resource_types): fold for fold in rules.compact_relation_folds} + vpc_attachment_fold = folds[("ALIYUN::CEN::TransitRouterVpcAttachment",)] + + assert vpc_attachment_fold.source_property == "TransitRouterId" + assert vpc_attachment_fold.target_property == "VpcId" + assert vpc_attachment_fold.edge_style == "dotted_open" + assert vpc_attachment_fold.edge_label == {"en": "VPC connection", "zh": "VPC连接"} + assert vpc_attachment_fold.render_as == "source_attachment" + + +def test_loads_supplemental_relations_and_child_attachment_rules(): + rules = ArchitectureRules.load_default() + + assert rules.supplemental_related_properties["ALIYUN::VPC::EIPAssociation"]["InstanceId"] == ( + "ALIYUN::ECS::NetworkInterface", + "ALIYUN::VPC::NatGateway", + ) + assert rules.supplemental_related_properties["ALIYUN::VPC::CommonBandwidthPackageIp"]["Eips"] == ( + "ALIYUN::VPC::EIP", + ) + assert rules.supplemental_related_properties["ALIYUN::VPC::AnycastEIPAssociation"]["BindInstanceId"] == ( + "ALIYUN::ECS::Instance", + "ALIYUN::ECS::NetworkInterface", + "ALIYUN::SLB::LoadBalancer", + "ALIYUN::VPC::HaVip", + ) + assert rules.supplemental_related_properties["ALIYUN::VPC::NetworkAclAssociation"]["Resources"] == ( + "ALIYUN::ECS::VSwitch", + ) + peering_relations = rules.supplemental_related_properties["ALIYUN::VPC::PeeringRouterInterfaceBinding"] + assert peering_relations["OppositeInterfaceId"] == ("ALIYUN::VPC::RouterInterface",) + assert "ALIYUN::ECS::NetworkInterface" in rules.compact_attachment_marker_types + assert { + "ALIYUN::CloudPhone::RunCommand", + "ALIYUN::ECS::Command", + "ALIYUN::ECS::Invocation", + "ALIYUN::ECS::RunCommand", + "ALIYUN::ECS::RunCommandOfLifespan", + "ALIYUN::SWAS::RunCommand", + }.issubset(rules.compact_orchestration_action_types) + assert "ALIYUN::ACTIONTRAIL::TrailLogging" not in rules.compact_orchestration_action_types + assert "ALIYUN::CMS::MetricRuleTemplateDeployment" not in rules.compact_orchestration_action_types + assert "ALIYUN::SLS::ServiceLog" not in rules.compact_orchestration_action_types + + nat_child_rules = { + tuple(rule.resource_types): (rule.target_properties, rule.target_types, rule.label) + for rule in rules.compact_child_attachments + } + assert nat_child_rules[("ALIYUN::VPC::SnatEntry",)] == ( + ("SnatTableId",), + ("ALIYUN::VPC::NatGateway",), + {"en": "SNAT entry", "zh": "SNAT条目"}, + ) + assert nat_child_rules[("ALIYUN::ECS::SNatEntry",)] == ( + ("SNatTableId",), + ("ALIYUN::VPC::NatGateway",), + {"en": "SNAT entry", "zh": "SNAT条目"}, + ) + assert nat_child_rules[("ALIYUN::VPC::ForwardEntry", "ALIYUN::ECS::ForwardEntry")] == ( + ("ForwardTableId",), + ("ALIYUN::VPC::NatGateway",), + {"en": "DNAT entry", "zh": "DNAT条目"}, + ) + assert nat_child_rules[("ALIYUN::VPC::CommonBandwidthPackageIp",)] == ( + ("BandwidthPackageId",), + ("ALIYUN::VPC::CommonBandwidthPackage",), + {"en": "Shared bandwidth IP", "zh": "共享带宽IP"}, + ) + + attachment_edges = {tuple(edge.resource_types): edge for edge in rules.compact_attachment_edges} + bandwidth_edge = attachment_edges[("ALIYUN::VPC::CommonBandwidthPackageIp",)] + assert bandwidth_edge.resource_types == ("ALIYUN::VPC::CommonBandwidthPackageIp",) + assert bandwidth_edge.source_properties == ("BandwidthPackageId",) + assert bandwidth_edge.marker_properties == ("Eips",) + assert bandwidth_edge.source_types == ("ALIYUN::VPC::CommonBandwidthPackage",) + assert bandwidth_edge.marker_types == ("ALIYUN::VPC::EIP",) + assert bandwidth_edge.edge_style == "dotted_open" + assert bandwidth_edge.edge_label == {"en": "public bandwidth", "zh": "公网带宽"} + assert ("ALIYUN::ECS::NetworkInterfaceAttachment",) not in attachment_edges + assert sum("ALIYUN::VPC::SnatEntry" in rule.resource_types for rule in rules.compact_child_attachments) == 1 + assert sum("ALIYUN::ECS::SNatEntry" in rule.resource_types for rule in rules.compact_child_attachments) == 1 + assert sum("ALIYUN::VPC::ForwardEntry" in rule.resource_types for rule in rules.compact_child_attachments) == 1 + assert sum("ALIYUN::ECS::ForwardEntry" in rule.resource_types for rule in rules.compact_child_attachments) == 1 + + +def test_loads_bridge_attachment_rules(): + rules = ArchitectureRules.load_default() + + bridge_rules = { + tuple(rule.resource_types): ( + rule.source_properties, + rule.via_resource_types, + rule.via_source_properties, + rule.via_target_properties, + rule.target_types, + rule.label, + ) + for rule in rules.compact_bridge_attachments + } + assert bridge_rules[("ALIYUN::NAS::AccessGroup",)] == ( + (), + ("ALIYUN::NAS::MountTarget",), + ("AccessGroupName",), + ("FileSystemId",), + ("ALIYUN::NAS::FileSystem",), + {"en": "NAS permission group", "zh": "NAS权限组"}, + ) + assert bridge_rules[("ALIYUN::NAS::AccessRule",)] == ( + ("AccessGroupName",), + ("ALIYUN::NAS::MountTarget",), + ("AccessGroupName",), + ("FileSystemId",), + ("ALIYUN::NAS::FileSystem",), + {"en": "NAS permission rule", "zh": "NAS权限规则"}, + ) + assert bridge_rules[("ALIYUN::ECD::NetworkPackage",)] == ( + (), + ("ALIYUN::ECD::NetworkPackageAssociation",), + ("NetworkPackageId",), + ("OfficeSiteId",), + ("ALIYUN::ECD::SimpleOfficeSite",), + {"en": "Bandwidth Plan", "zh": "带宽包"}, + ) + assert bridge_rules[("ALIYUN::SAG::SmartAccessGateway",)][0] == () + assert bridge_rules[("ALIYUN::VPC::DhcpOptionsSet",)][0] == () + assert bridge_rules[("ALIYUN::VPC::RouterInterface",)][0] == () + assert ("ALIYUN::VPC::HaVip",) not in bridge_rules diff --git a/tests/pipeline/engine/test_display_replay.py b/tests/pipeline/engine/test_display_replay.py index 1a4eab1a..5aca6c5d 100644 --- a/tests/pipeline/engine/test_display_replay.py +++ b/tests/pipeline/engine/test_display_replay.py @@ -251,7 +251,16 @@ def test_reducer_tracks_candidate_selection_phases(tmp_path): recorder.record( "candidate_diagram", step_id="confirm_and_select", - payload={"candidate_name": "低成本方案", "candidate_index": 0, "mermaid_source": "graph TD; A-->B"}, + payload={ + "candidate_name": "低成本方案", + "candidate_index": 0, + "mermaid_source": "graph TD; A-->B", + "diagram_stage": "optimized", + "views": [ + {"id": "overview", "title": "架构概览", "mermaid_source": "graph TD; A-->B"}, + {"id": "detail_app", "title": "应用详情", "mermaid_source": "graph TD; C-->D"}, + ], + }, ) recorder.record( "candidate_detail", @@ -267,6 +276,8 @@ def test_reducer_tracks_candidate_selection_phases(tmp_path): preparing = PipelineDisplayReducer().reduce(load_display_events(path)).attempts[-1].candidate_selection assert preparing.state == "preparing" + assert preparing.candidates[0].diagram_stage == "optimized" + assert [view["id"] for view in preparing.candidates[0].diagram_views] == ["overview", "detail_app"] assert preparing.candidates[0].summary == "单 ECS Nginx" options = [{"name": "低成本方案", "summary": "单 ECS Nginx", "candidate_index": 0}] diff --git a/tests/pipeline/engine/test_show_diagram_tool.py b/tests/pipeline/engine/test_show_diagram_tool.py index 48046de8..9a444cc7 100644 --- a/tests/pipeline/engine/test_show_diagram_tool.py +++ b/tests/pipeline/engine/test_show_diagram_tool.py @@ -2,10 +2,23 @@ import pytest +from iac_code.pipeline.engine import show_diagram_tool from iac_code.pipeline.engine.show_diagram_tool import ShowArchitectureDiagramTool, ros_template_to_mermaid -from iac_code.tools.base import Tool, ToolContext, ToolResult +from iac_code.tools.base import Tool, ToolContext, ToolRegistry, ToolResult +from iac_code.tools.tool_executor import ToolCallRequest, ToolExecutor from iac_code.types.stream_events import CandidateDetailEvent, DiagramEvent, ToolEmittedEvent + +def _assert_error_diagram_event(queue: asyncio.Queue, *, candidate_name: str, expected_text: str) -> None: + event = queue.get_nowait() + assert isinstance(event, DiagramEvent) + assert event.candidate_name == candidate_name + assert event.diagram_stage == "optimized" + assert expected_text in event.mermaid_source + assert event.views + assert expected_text in event.views[0]["mermaid_source"] + + SIMPLE_TEMPLATE = """\ ROSTemplateFormatVersion: '2015-09-01' Resources: @@ -117,6 +130,34 @@ """ +def _many_resource_template(count: int = 80) -> str: + resources = [ + "ROSTemplateFormatVersion: '2015-09-01'", + "Resources:", + " VPC:", + " Type: ALIYUN::ECS::VPC", + " Properties:", + " CidrBlock: 10.0.0.0/8", + " VSwitch:", + " Type: ALIYUN::ECS::VSwitch", + " Properties:", + " VpcId:", + " Ref: VPC", + " CidrBlock: 10.0.0.0/24", + ] + for index in range(count): + resources.extend( + [ + f" ECS{index}:", + " Type: ALIYUN::ECS::Instance", + " Properties:", + " VSwitchId:", + " Ref: VSwitch", + ] + ) + return "\n".join(resources) + "\n" + + class TestToolEmittedEvent: def test_diagram_event_is_tool_emitted(self): event = DiagramEvent( @@ -179,9 +220,9 @@ class TestRosTemplateToMermaid: def test_layers_rendered_as_subgraphs(self): mermaid = ros_template_to_mermaid(SIMPLE_TEMPLATE) assert "graph TD" in mermaid - assert 'subgraph layer_VPC["VPC (172.16.0.0/12)"]' in mermaid - assert 'subgraph layer_VSwitch["VSwitch (172.16.0.0/24)"]' in mermaid - assert 'subgraph layer_SecurityGroup["Security group"]' in mermaid + assert "subgraph layer_VPC [VPC (172.16.0.0/12)]" in mermaid + assert "subgraph layer_VSwitch [VSwitch (172.16.0.0/24)]" in mermaid + assert "subgraph layer_SecurityGroup [Security group]" in mermaid def test_node_inside_security_group(self): mermaid = ros_template_to_mermaid(SIMPLE_TEMPLATE) @@ -276,6 +317,12 @@ def test_needs_event_queue(self): tool = ShowArchitectureDiagramTool() assert tool.needs_event_queue() is True + def test_timeout_allows_slow_semantic_planning(self): + tool = ShowArchitectureDiagramTool() + + assert tool.timeout is not None + assert tool.timeout >= 600.0 + class TestShowArchitectureDiagramToolExecute: @pytest.mark.asyncio @@ -301,6 +348,33 @@ async def test_emits_diagram_event(self, tmp_path): assert "graph TD" in event.mermaid_source assert "ROSTemplateFormatVersion" in event.template_content + @pytest.mark.asyncio + async def test_uses_requested_template_file_path(self, tmp_path): + template_dir = tmp_path / "templates" + template_dir.mkdir() + requested_template = SIMPLE_TEMPLATE.replace("172.16.0.0/12", "10.10.0.0/16") + debug_template = SIMPLE_TEMPLATE.replace("172.16.0.0/12", "192.168.99.0/24") + (template_dir / "requested.yml").write_text(requested_template, encoding="utf-8") + (template_dir / "public-network-architecture-design.yml").write_text(debug_template, encoding="utf-8") + queue: asyncio.Queue = asyncio.Queue() + tool = ShowArchitectureDiagramTool() + + result = await tool.execute( + tool_input={ + "file_path": "templates/requested.yml", + "candidate_name": "requested candidate", + "candidate_index": 0, + }, + context=ToolContext(cwd=str(tmp_path), event_queue=queue), + ) + + assert not result.is_error + event = queue.get_nowait() + assert isinstance(event, DiagramEvent) + assert event.template_content == requested_template + assert "10.10.0.0/16" in event.mermaid_source + assert "192.168.99.0/24" not in event.mermaid_source + @pytest.mark.asyncio async def test_show_architecture_diagram_emits_candidate_index(self, tmp_path): template = tmp_path / "template.yml" @@ -319,17 +393,387 @@ async def test_show_architecture_diagram_emits_candidate_index(self, tmp_path): assert event.candidate_name == "Same" assert event.candidate_index == 1 + @pytest.mark.asyncio + async def test_facts_mode_emits_draft_then_optimized_diagram(self, tmp_path, monkeypatch): + template = tmp_path / "template.yml" + template.write_text(SLB_TEMPLATE, encoding="utf-8") + queue: asyncio.Queue = asyncio.Queue() + tool = ShowArchitectureDiagramTool() + + async def fake_create_semantic_plan_for_architecture_with_llm( + architecture_context: dict, + template_content: str, + **_: object, + ): + assert architecture_context + assert "SLB" in template_content + return { + "edges": [ + { + "from": "SLB", + "to": "ECS1", + "kind": "traffic", + "label": "后端转发", + "confidence": "high", + } + ] + } + + monkeypatch.setattr( + show_diagram_tool, + "create_semantic_plan_for_architecture_with_llm", + fake_create_semantic_plan_for_architecture_with_llm, + ) + + result = await tool.execute( + tool_input={ + "file_path": "template.yml", + "candidate_name": "semantic plan candidate", + "candidate_index": 0, + "mode": "facts", + }, + context=ToolContext(cwd=str(tmp_path), event_queue=queue), + ) + + assert not result.is_error + draft_event = queue.get_nowait() + optimized_event = queue.get_nowait() + assert isinstance(draft_event, DiagramEvent) + assert isinstance(optimized_event, DiagramEvent) + assert draft_event.diagram_stage == "draft" + assert optimized_event.diagram_stage == "optimized" + assert len(draft_event.views) == 1 + assert draft_event.views[0]["id"] == "overview" + assert "graph TD" in draft_event.views[0]["mermaid_source"] + assert "后端转发" in optimized_event.mermaid_source + assert "Architecture semantic planning instructions" not in result.content + assert '"visible_nodes"' not in result.content + + @pytest.mark.asyncio + async def test_facts_mode_uses_internal_preview_semantic_planning_for_large_templates(self, tmp_path, monkeypatch): + template = tmp_path / "template.yml" + template.write_text(_many_resource_template(), encoding="utf-8") + queue: asyncio.Queue = asyncio.Queue() + tool = ShowArchitectureDiagramTool() + captured_contexts: list[dict] = [] + + async def fake_create_semantic_plan_for_architecture_with_llm( + architecture_context: dict, + template_content: str, + **_: object, + ): + captured_contexts.append(architecture_context) + assert "Resource0" in template_content + return {} + + monkeypatch.setattr( + show_diagram_tool, + "create_semantic_plan_for_architecture_with_llm", + fake_create_semantic_plan_for_architecture_with_llm, + ) + + result = await tool.execute( + tool_input={ + "file_path": "template.yml", + "candidate_name": "large candidate", + "candidate_index": 0, + "mode": "facts", + }, + context=ToolContext(cwd=str(tmp_path), event_queue=queue), + ) + + assert not result.is_error + assert captured_contexts + draft_event = queue.get_nowait() + optimized_event = queue.get_nowait() + assert isinstance(draft_event, DiagramEvent) + assert isinstance(optimized_event, DiagramEvent) + assert draft_event.diagram_stage == "draft" + assert optimized_event.diagram_stage == "optimized" + assert len(result.content) < 1000 + assert "MUST call show_architecture_diagram again with mode=render" not in result.content + assert "Architecture semantic planning instructions" not in result.content + assert '"visible_nodes"' not in result.content + assert '"resources"' not in result.content + + @pytest.mark.asyncio + async def test_facts_mode_emits_optimized_diagram_from_internal_llm_plan(self, tmp_path, monkeypatch): + template = tmp_path / "templates" / "public-network-architecture-design.yml" + template.parent.mkdir() + template.write_text(SLB_TEMPLATE, encoding="utf-8") + queue: asyncio.Queue = asyncio.Queue() + tool = ShowArchitectureDiagramTool() + captured_contexts: list[dict] = [] + + async def fake_create_semantic_plan_for_architecture_with_llm( + architecture_context: dict, + template_content: str, + **_: object, + ): + captured_contexts.append(architecture_context) + assert "SLB" in template_content + return { + "edges": [ + { + "from": "SLB", + "to": "ECS1", + "kind": "traffic", + "label": "后端转发", + "confidence": "high", + } + ], + "views": [ + { + "id": "detail_app", + "title": "应用负载详情", + "purpose": "展示负载均衡到后端服务器的流量路径", + "layout": "flat", + "anchors": ["SLB"], + "groups": [], + "nodes": ["SLB", "ECS1"], + "edges": [ + { + "from": "SLB", + "to": "ECS1", + "kind": "traffic", + "label": "后端转发", + } + ], + } + ], + } + + monkeypatch.setattr( + show_diagram_tool, + "create_semantic_plan_for_architecture_with_llm", + fake_create_semantic_plan_for_architecture_with_llm, + raising=False, + ) + + result = await tool.execute( + tool_input={ + "file_path": "templates/public-network-architecture-design.yml", + "candidate_name": "semantic plan candidate", + "candidate_index": 0, + "mode": "facts", + }, + context=ToolContext(cwd=str(tmp_path), event_queue=queue), + ) + + assert not result.is_error + draft_event = queue.get_nowait() + optimized_event = queue.get_nowait() + assert isinstance(draft_event, DiagramEvent) + assert isinstance(optimized_event, DiagramEvent) + assert draft_event.diagram_stage == "draft" + assert optimized_event.diagram_stage == "optimized" + assert optimized_event.views[0]["id"] == "detail_app" + assert "后端转发" in optimized_event.views[0]["mermaid_source"] + assert captured_contexts + assert "Architecture semantic planning instructions" not in result.content + assert '"visible_nodes"' not in result.content + + @pytest.mark.asyncio + async def test_facts_mode_emits_fallback_optimized_event_when_executor_cancels_llm(self, tmp_path, monkeypatch): + class ShortTimeoutShowArchitectureDiagramTool(ShowArchitectureDiagramTool): + @property + def timeout(self) -> float | None: + return 0.05 + + template = tmp_path / "template.yml" + template.write_text(SLB_TEMPLATE, encoding="utf-8") + queue: asyncio.Queue = asyncio.Queue() + registry = ToolRegistry() + registry.register(ShortTimeoutShowArchitectureDiagramTool()) + executor = ToolExecutor(registry, tool_timeout=0.05) + + async def slow_create_semantic_plan_for_architecture_with_llm( + architecture_context: dict, + template_content: str, + **_: object, + ): + assert architecture_context + assert template_content + await asyncio.sleep(10) + return {} + + monkeypatch.setattr( + show_diagram_tool, + "create_semantic_plan_for_architecture_with_llm", + slow_create_semantic_plan_for_architecture_with_llm, + ) + + results = await executor.execute_batch( + [ + ToolCallRequest( + id="call_1", + name="show_architecture_diagram", + input={ + "file_path": "template.yml", + "candidate_name": "semantic plan candidate", + "candidate_index": 0, + "mode": "facts", + }, + event_queue=queue, + ) + ], + ToolContext(cwd=str(tmp_path)), + ) + + assert results[0].is_error + draft_event = queue.get_nowait() + optimized_event = queue.get_nowait() + assert isinstance(draft_event, DiagramEvent) + assert isinstance(optimized_event, DiagramEvent) + assert draft_event.diagram_stage == "draft" + assert optimized_event.diagram_stage == "optimized" + + @pytest.mark.asyncio + async def test_render_mode_applies_valid_semantic_plan(self, tmp_path): + template = tmp_path / "template.yml" + template.write_text(SLB_TEMPLATE, encoding="utf-8") + queue: asyncio.Queue = asyncio.Queue() + tool = ShowArchitectureDiagramTool() + + result = await tool.execute( + tool_input={ + "file_path": "template.yml", + "candidate_name": "semantic plan candidate", + "candidate_index": 0, + "semantic_plan": { + "edges": [ + { + "from": "SLB", + "to": "ECS1", + "kind": "traffic", + "label": "forwards traffic", + "confidence": "medium", + } + ] + }, + }, + context=ToolContext(cwd=str(tmp_path), event_queue=queue), + ) + + assert not result.is_error + event = queue.get_nowait() + assert isinstance(event, DiagramEvent) + assert event.diagram_stage == "optimized" + assert "SLB -->|forwards traffic| ECS1" in event.mermaid_source + assert "SLB --> ECS1" not in event.mermaid_source + assert event.architecture_context is not None + assert event.architecture_context["semantic_plan"]["accepted_edges"][0]["label"] == "forwards traffic" + + @pytest.mark.asyncio + async def test_render_mode_emits_multiple_views_from_semantic_plan(self, tmp_path): + template = tmp_path / "template.yml" + template.write_text(SLB_TEMPLATE, encoding="utf-8") + queue: asyncio.Queue = asyncio.Queue() + tool = ShowArchitectureDiagramTool() + + result = await tool.execute( + tool_input={ + "file_path": "template.yml", + "candidate_name": "multi view candidate", + "candidate_index": 0, + "mode": "render", + "semantic_plan": { + "views": [ + { + "id": "overview", + "title": "总览", + "purpose": "整体拓扑", + "node_ids": ["SLB", "ECS1"], + "edge_ids": [], + }, + { + "id": "detail_app", + "title": "应用详情", + "purpose": "应用层", + "node_ids": ["SLB", "ECS1", "ECS2"], + "edge_ids": [], + }, + ] + }, + }, + context=ToolContext(cwd=str(tmp_path), event_queue=queue), + ) + + assert not result.is_error + event = queue.get_nowait() + assert isinstance(event, DiagramEvent) + assert event.diagram_stage == "optimized" + assert [(view["id"], view["title"]) for view in event.views] == [ + ("overview", "总览"), + ("detail_app", "应用详情"), + ] + + @pytest.mark.asyncio + async def test_render_mode_repairs_preview_semantic_plan_before_rendering(self, tmp_path): + template = tmp_path / "template.yml" + template.write_text(SLB_TEMPLATE, encoding="utf-8") + queue: asyncio.Queue = asyncio.Queue() + tool = ShowArchitectureDiagramTool() + + result = await tool.execute( + tool_input={ + "file_path": "template.yml", + "candidate_name": "repaired plan candidate", + "candidate_index": 0, + "mode": "render", + "semantic_plan": { + "node_labels": [ + {"id": "SLB", "label": "入口负载均衡", "confidence": "high", "reason": "obvious"}, + {"id": "Missing", "label": "不存在", "confidence": "high", "reason": "bad"}, + ], + "edges": [ + {"from": "SLB", "to": "ECS1", "kind": "traffic", "label": "后端转发"}, + {"from": "SLB", "to": "Missing", "kind": "traffic", "label": "错误关系"}, + ], + "views": [ + { + "id": "detail_app", + "layout": "deep", + "nodes": ["SLB", "Missing"], + "edges": [{"from": "SLB", "to": "Missing", "kind": "traffic", "label": "错误关系"}], + }, + { + "id": "overview", + "layout": "flat", + "nodes": ["SLB", "ECS1"], + "edges": [{"from": "SLB", "to": "ECS1", "kind": "traffic", "label": "后端转发"}], + }, + ], + }, + }, + context=ToolContext(cwd=str(tmp_path), event_queue=queue), + ) + + assert not result.is_error + event = queue.get_nowait() + assert isinstance(event, DiagramEvent) + assert event.diagram_stage == "optimized" + assert [(view["id"], view["title"]) for view in event.views] == [ + ("overview", "overview"), + ("detail_app", "detail_app"), + ] + accepted_labels = event.architecture_context["semantic_plan"]["accepted_node_labels"] + assert accepted_labels == [{"id": "SLB", "label": "入口负载均衡", "confidence": "high"}] + assert all("Missing" not in view["mermaid_source"] for view in event.views) + @pytest.mark.asyncio async def test_file_not_found(self, tmp_path): - context = ToolContext(cwd=str(tmp_path)) + queue: asyncio.Queue = asyncio.Queue() + context = ToolContext(cwd=str(tmp_path), event_queue=queue) tool = ShowArchitectureDiagramTool() result = await tool.execute( - tool_input={"file_path": "templates/nonexistent.yml", "candidate_name": "不存在"}, + tool_input={"file_path": "templates/nonexistent.yml", "candidate_name": "不存在", "candidate_index": 0}, context=context, ) assert result.is_error + _assert_error_diagram_event(queue, candidate_name="不存在", expected_text="Template file does not exist") @pytest.mark.asyncio @pytest.mark.parametrize("file_path", ["../secret.yml", "../../secret.yml"]) @@ -346,7 +790,7 @@ async def test_rejects_parent_directory_escape(self, tmp_path, file_path): ) assert result.is_error - assert queue.empty() + _assert_error_diagram_event(queue, candidate_name="逃逸方案", expected_text="cannot escape") @pytest.mark.asyncio async def test_rejects_absolute_path(self, tmp_path): @@ -363,7 +807,7 @@ async def test_rejects_absolute_path(self, tmp_path): ) assert result.is_error - assert queue.empty() + _assert_error_diagram_event(queue, candidate_name="绝对路径方案", expected_text="must be relative") @pytest.mark.asyncio async def test_rejects_symlink_escape(self, tmp_path): @@ -386,7 +830,7 @@ async def test_rejects_symlink_escape(self, tmp_path): ) assert result.is_error - assert queue.empty() + _assert_error_diagram_event(queue, candidate_name="链接逃逸方案", expected_text="cannot escape") @pytest.mark.asyncio async def test_no_event_queue(self, tmp_path): diff --git a/tests/pipeline/selling/test_terminal_ui_contract.py b/tests/pipeline/selling/test_terminal_ui_contract.py index 491b9fcd..18f96735 100644 --- a/tests/pipeline/selling/test_terminal_ui_contract.py +++ b/tests/pipeline/selling/test_terminal_ui_contract.py @@ -43,6 +43,59 @@ def test_confirm_prompt_tells_model_to_output_candidate_index(): assert "`options[].candidate_index`" in prompt +def test_confirm_prompt_shows_candidate_detail_in_same_round_as_architecture_diagram(): + prompt = (_selling_pipeline_dir() / "prompts" / "confirm_and_select.md").read_text(encoding="utf-8") + + diagram_pos = prompt.index("调用一次 `show_architecture_diagram`") + detail_pos = prompt.index("调用 `show_candidate_detail` 工具") + + assert diagram_pos < detail_pos + assert "在同一个工具调用轮次中，同时调用以下两个只读展示工具" in prompt + assert "先为所有方案调用 `show_architecture_diagram`，再为所有方案调用 `show_candidate_detail`" not in prompt + + +def test_confirm_prompt_forbids_completion_before_optimized_architecture_diagram(): + prompt = (_selling_pipeline_dir() / "prompts" / "confirm_and_select.md").read_text(encoding="utf-8") + + assert "在 `show_architecture_diagram` 工具返回之前，不要调用 `complete_step`" in prompt + + +def test_confirm_prompt_does_not_ask_main_model_to_generate_semantic_plan(): + prompt = (_selling_pipeline_dir() / "prompts" / "confirm_and_select.md").read_text(encoding="utf-8") + + assert "不要根据工具返回内容自行生成 `semantic_plan`" in prompt + assert "不要为同一候选方案再调用第二次 `show_architecture_diagram`" in prompt + assert "随后第二次调用 `show_architecture_diagram`" not in prompt + assert "`semantic_plan_scaffold`" not in prompt + assert "非平凡架构" not in prompt + + +def test_confirm_step_only_exposes_selection_display_tools(): + from unittest.mock import MagicMock + + from iac_code.pipeline.engine.context import PipelineContext + from iac_code.pipeline.engine.step_executor import StepExecutor + from iac_code.tools.base import ToolRegistry + + loaded = load_pipeline_dir(_selling_pipeline_dir()) + confirm = next(step for step in loaded.steps if step.step_id == "confirm_and_select") + registry = ToolRegistry() + registry.register_default_tools() + executor = StepExecutor( + provider_manager=MagicMock(), + base_tool_registry=registry, + pipeline=loaded, + pipeline_dir=_selling_pipeline_dir(), + ) + + tool_reg = executor._build_step_tools(confirm, PipelineContext({"evaluated_candidates": []})) + + assert tool_reg.get("complete_step") is not None + assert tool_reg.get("show_architecture_diagram") is not None + assert tool_reg.get("show_candidate_detail") is not None + assert tool_reg.get("read_file") is None + + def test_confirm_prompt_tells_model_to_preserve_parameter_overrides(): prompt = (_selling_pipeline_dir() / "prompts" / "confirm_and_select.md").read_text(encoding="utf-8") diff --git a/tests/providers/test_dashscope_provider.py b/tests/providers/test_dashscope_provider.py index d753b44f..bff38154 100644 --- a/tests/providers/test_dashscope_provider.py +++ b/tests/providers/test_dashscope_provider.py @@ -75,6 +75,10 @@ def test_qwen_with_effort_still_only_enable_thinking(self): p = DashScopeProvider(model="qwen3.6-plus", api_key="k", effort="high") assert p._build_thinking_kwargs() == {"extra_body": {"enable_thinking": True}} + def test_qwen_with_effort_none_disables_thinking(self): + p = DashScopeProvider(model="qwen3.7-max", api_key="k", effort="none") + assert p._build_thinking_kwargs() == {"extra_body": {"enable_thinking": False}} + def test_kimi(self): p = DashScopeProvider(model="kimi-k2.6", api_key="k") assert p._build_thinking_kwargs() == {"extra_body": {"enable_thinking": True}} @@ -416,6 +420,38 @@ def test_last_user_message_gets_cache_control(self): assert last_user["content"][0]["text"] == "second" assert last_user["content"][0]["cache_control"] == {"type": "ephemeral"} + def test_last_user_message_dynamic_boundary_caches_only_static_prefix(self): + """Supported model: user message dynamic boundary keeps changing retry text outside the cache marker.""" + p = DashScopeProvider(model="qwen3.5-plus", api_key="k") + msg = Message.user(f"FACT BUNDLE\n\n{DYNAMIC_BOUNDARY}\n\nATTEMPT INSTRUCTION") + api = p._build_api_messages([msg], "sys") + + last_user = api[-1] + assert last_user["role"] == "user" + assert last_user["content"] == [ + {"type": "text", "text": "FACT BUNDLE", "cache_control": {"type": "ephemeral"}}, + {"type": "text", "text": "ATTEMPT INSTRUCTION"}, + ] + + def test_non_last_user_message_with_dynamic_boundary_gets_cache_control(self): + """Append-style retries keep first-turn facts cacheable even after later user turns are appended.""" + p = DashScopeProvider(model="qwen3.5-plus", api_key="k") + msgs = [ + Message.user(f"FACT BUNDLE\n\n{DYNAMIC_BOUNDARY}\n\nATTEMPT 1"), + Message.assistant_text('{"node_labels":[]}'), + Message.user("ATTEMPT 2"), + ] + api = p._build_api_messages(msgs, "sys") + + first_user = api[1] + last_user = api[-1] + assert first_user["role"] == "user" + assert first_user["content"] == [ + {"type": "text", "text": "FACT BUNDLE", "cache_control": {"type": "ephemeral"}}, + {"type": "text", "text": "ATTEMPT 1"}, + ] + assert last_user["content"] == [{"type": "text", "text": "ATTEMPT 2", "cache_control": {"type": "ephemeral"}}] + def test_first_user_not_tagged_when_multiple(self): """Only the *last* user message gets cache_control, not earlier ones.""" p = DashScopeProvider(model="qwen3.5-plus", api_key="k") diff --git a/tests/providers/test_manager.py b/tests/providers/test_manager.py index 616614fe..a00b1144 100644 --- a/tests/providers/test_manager.py +++ b/tests/providers/test_manager.py @@ -167,6 +167,13 @@ def test_non_openai_provider_ignores_request_policy_config(self, monkeypatch): assert not hasattr(p, "_thinking_budget") assert not hasattr(p, "_max_completion_tokens") + def test_effort_override_takes_precedence_over_settings(self, monkeypatch): + monkeypatch.setattr("iac_code.config.get_active_provider_key", lambda: "dashscope") + monkeypatch.setattr("iac_code.config.get_provider_config", lambda name: {"effort": "high"}) + p = create_provider("qwen3.7-max", credentials={"dashscope": "key"}, effort_override="none") + assert getattr(p, "_effort", None) == "none" + assert getattr(p, "_thinking_enabled", None) is False + def test_unknown_raises(self, monkeypatch): """Unknown model with no saved provider config raises ValueError.""" monkeypatch.setattr("iac_code.config.get_active_provider_key", lambda: None) @@ -296,6 +303,19 @@ def test_provider_key_and_display_use_runtime_override(self, monkeypatch): assert m.get_provider_key() == "dashscope_token_plan" assert m.get_provider_display() == "Alibaba Cloud Bailian Token Plan" + def test_effort_override_is_passed_to_provider(self, monkeypatch): + monkeypatch.setattr("iac_code.config.get_active_provider_key", lambda: "dashscope") + monkeypatch.setattr("iac_code.config.get_provider_config", lambda name: {"effort": "high"}) + m = ProviderManager( + model="qwen3.7-max", + credentials={"dashscope": "key"}, + effort_override="none", + ) + + assert m._provider is not None + assert getattr(m._provider, "_effort", None) == "none" + assert getattr(m._provider, "_thinking_enabled", None) is False + def test_reconfigure_swaps_model_and_credentials(self, monkeypatch): monkeypatch.setattr("iac_code.config.get_active_provider_key", lambda: "anthropic") m = ProviderManager(model="claude-sonnet-4-6", credentials={"anthropic": "old"}) diff --git a/tests/scripts/test_analyze_ros_resource_architecture_rules.py b/tests/scripts/test_analyze_ros_resource_architecture_rules.py new file mode 100644 index 00000000..90af3ba4 --- /dev/null +++ b/tests/scripts/test_analyze_ros_resource_architecture_rules.py @@ -0,0 +1,95 @@ +from __future__ import annotations + +import importlib.util +import json +from pathlib import Path + +from iac_code.pipeline.engine.architecture_meta import ArchitectureMetaRepository +from iac_code.pipeline.engine.architecture_resource_inventory import ( + RosResourceTypeDetail, + build_resource_inventory_snapshot, +) +from iac_code.pipeline.engine.architecture_rule_candidates import ( + build_resource_type_decisions, + extract_rule_candidates, +) + + +def _load_script_module(): + script_path = Path("scripts/rendering/analyze_ros_resource_architecture_rules.py") + spec = importlib.util.spec_from_file_location("analyze_ros_resource_architecture_rules", script_path) + assert spec is not None + assert spec.loader is not None + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +def _snapshot(): + repo = ArchitectureMetaRepository.from_raw( + categories=[{"CategoryCode": "network", "ProductCodes": ["ecs"]}], + products=[{"ProductCode": "ecs", "Name": {"en": "ECS", "zh": "云服务器"}, "RelevantCodes": {"ROS": "ECS"}}], + config=[ + { + "ResourceType": {"ROS": "ROS/ALIYUN::ECS::VPC"}, + "ProductCode": "ecs", + "Name": {"en": "VPC", "zh": "专有网络 VPC"}, + "Properties": [], + }, + { + "ResourceType": {"ROS": "ROS/ALIYUN::ECS::RunCommand"}, + "ProductCode": "ecs", + "Name": {"en": "Run Command", "zh": "执行命令"}, + "Properties": [ + { + "ROS": "InstanceIds", + "RelatedTo": [{"ResourceType": "ROS/ALIYUN::ECS::Instance"}], + } + ], + }, + ], + ) + return build_resource_inventory_snapshot( + api_resource_types=["ALIYUN::ECS::VPC", "ALIYUN::ECS::RunCommand"], + details_by_type={ + "ALIYUN::ECS::RunCommand": RosResourceTypeDetail( + resource_type="ALIYUN::ECS::RunCommand", + entity_type="Resource", + provider="ROS", + properties={"CommandContent": {"Description": "The command content."}}, + attributes={}, + description="Runs a Cloud Assistant command on ECS instances.", + ) + }, + meta_repository=repo, + fetched_at="2026-06-26T00:00:00Z", + ) + + +def test_write_analysis_outputs_creates_json_and_markdown(tmp_path: Path) -> None: + module = _load_script_module() + snapshot = _snapshot() + candidates = extract_rule_candidates(snapshot) + decisions = build_resource_type_decisions(snapshot, candidates) + json_out = tmp_path / "report.json" + markdown_out = tmp_path / "report.md" + + module.write_analysis_outputs( + snapshot=snapshot, + candidates=candidates, + decisions=decisions, + json_out=json_out, + markdown_out=markdown_out, + ) + + payload = json.loads(json_out.read_text(encoding="utf-8")) + assert payload["summary"]["api_resource_types"] == 2 + assert payload["summary"]["resource_facts"] == 2 + assert payload["resource_facts"] + assert payload["rule_signals"] + assert "decisions" not in payload + assert "candidates" not in payload + + markdown = markdown_out.read_text(encoding="utf-8") + assert "# ROS 架构图 Resource Facts / Rule Signals" in markdown + assert "`ALIYUN::ECS::RunCommand`" in markdown diff --git a/tests/scripts/test_generate_ros_architecture_draft_rules.py b/tests/scripts/test_generate_ros_architecture_draft_rules.py new file mode 100644 index 00000000..f0b6fac9 --- /dev/null +++ b/tests/scripts/test_generate_ros_architecture_draft_rules.py @@ -0,0 +1,393 @@ +from __future__ import annotations + +import importlib.util +import json +from pathlib import Path + + +def _load_script_module(): + script_path = Path("scripts/rendering/generate_ros_architecture_draft_rules.py") + spec = importlib.util.spec_from_file_location("generate_ros_architecture_draft_rules", script_path) + assert spec is not None + assert spec.loader is not None + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +def _facts_payload() -> dict: + return { + "summary": {"api_resource_types": 2, "resource_facts": 2, "rule_signals": 2}, + "resource_facts": [ + { + "resource_type": "ALIYUN::VPC::SnatEntry", + "product_code": "vpc", + "source_state": "api+local", + "name": {"zh": "SNAT条目", "en": "SNAT entry"}, + "description": "SNAT entries configure internet access through a NAT gateway.", + "properties": {"SnatTableId": {"description": "The SNAT table ID."}}, + "related_properties": {"SnatTableId": ["ALIYUN::VPC::NatGateway"]}, + "main_resource_type": None, + "fixed_rule_hits": [], + }, + { + "resource_type": "ALIYUN::ECS::RunCommand", + "product_code": "ecs", + "source_state": "api+local", + "name": {"zh": "执行命令", "en": "Run command"}, + "description": "Runs a Cloud Assistant command on ECS instances.", + "properties": {"InstanceIds": {"description": "ECS instances."}}, + "related_properties": {"InstanceIds": ["ALIYUN::ECS::Instance"]}, + "main_resource_type": None, + "fixed_rule_hits": [], + }, + ], + "rule_signals": [ + { + "category": "attachment", + "resource_type": "ALIYUN::VPC::SnatEntry", + "property_name": "SnatTableId", + "target_resource_types": ["ALIYUN::VPC::NatGateway"], + "confidence": "medium", + "evidence": ["SNAT entry points to NAT gateway."], + "suggested_patch": {}, + }, + { + "category": "orchestration_action", + "resource_type": "ALIYUN::ECS::RunCommand", + "property_name": None, + "target_resource_types": ["ALIYUN::ECS::Instance"], + "confidence": "high", + "evidence": ["Runs command on ECS instances."], + "suggested_patch": {}, + }, + ], + } + + +def test_chunks_facts_and_reuses_cached_llm_draft_results(tmp_path: Path) -> None: + module = _load_script_module() + facts_path = tmp_path / "facts.json" + cache_path = tmp_path / "draft-cache.json" + facts_path.write_text(json.dumps(_facts_payload(), ensure_ascii=False), encoding="utf-8") + cache_path.write_text( + json.dumps( + { + "chunks": { + "vpc": { + "fingerprint": module.chunk_fingerprint( + module.chunk_resource_facts(_facts_payload(), max_facts_per_chunk=1)[1] + ), + "response_text": json.dumps( + { + "draft_rules": [ + { + "resource_type": "ALIYUN::VPC::SnatEntry", + "classification": "attachment", + "target_resource_types": ["ALIYUN::VPC::NatGateway"], + "property_names": ["SnatTableId"], + "label": "SNAT entry", + "edge_label": None, + "confidence": 0.91, + "evidence": ["cached"], + "suggested_architecture_rules_patch": {"compact_child_attachments": []}, + } + ] + } + ), + } + } + }, + ensure_ascii=False, + ), + encoding="utf-8", + ) + calls: list[str] = [] + + async def fake_llm(prompt: str) -> str: + calls.append(prompt) + return json.dumps( + { + "draft_rules": [ + { + "resource_type": "ALIYUN::ECS::RunCommand", + "classification": "orchestration_action", + "target_resource_types": ["ALIYUN::ECS::Instance"], + "property_names": ["InstanceIds"], + "label": "Cloud Assistant execution", + "edge_label": "runs command", + "confidence": 0.89, + "evidence": ["generated"], + "suggested_architecture_rules_patch": {"compact_orchestration_actions": []}, + } + ] + } + ) + + result = module.run_draft_generation_from_facts_payload( + _facts_payload(), + cache_path=cache_path, + max_facts_per_chunk=1, + complete_chunk=fake_llm, + ) + + assert [chunk["chunk_id"] for chunk in module.chunk_resource_facts(_facts_payload(), max_facts_per_chunk=1)] == [ + "ecs", + "vpc", + ] + assert len(result["draft_rules"]) == 2 + assert [rule["resource_type"] for rule in result["draft_rules"]] == [ + "ALIYUN::ECS::RunCommand", + "ALIYUN::VPC::SnatEntry", + ] + assert len(calls) == 1 + assert "ALIYUN::ECS::RunCommand" in calls[0] + assert "ALIYUN::VPC::SnatEntry" not in calls[0] + + cache = json.loads(cache_path.read_text(encoding="utf-8")) + assert set(cache["chunks"]) == {"ecs", "vpc"} + + +def test_draft_cache_ignores_stale_chunk_fingerprints(tmp_path: Path) -> None: + module = _load_script_module() + cache_path = tmp_path / "draft-cache.json" + cache_path.write_text( + json.dumps({"chunks": {"ecs": {"fingerprint": "stale", "response_text": "not json"}}}), + encoding="utf-8", + ) + calls: list[str] = [] + + async def fake_llm(prompt: str) -> str: + calls.append(prompt) + return json.dumps({"draft_rules": []}) + + result = module.run_draft_generation_from_facts_payload( + _facts_payload(), + cache_path=cache_path, + max_facts_per_chunk=1, + complete_chunk=fake_llm, + ) + + assert result["summary"]["parse_errors"] == 0 + assert len(calls) == 2 + cache = json.loads(cache_path.read_text(encoding="utf-8")) + assert cache["chunks"]["ecs"]["fingerprint"] != "stale" + + +def test_global_chunk_mode_packs_multiple_products_into_bounded_batches() -> None: + module = _load_script_module() + payload = _facts_payload() + + chunks = module.chunk_resource_facts(payload, max_facts_per_chunk=2, mode="global") + + assert len(chunks) == 1 + assert chunks[0]["chunk_id"] == "all-1" + assert [fact["resource_type"] for fact in chunks[0]["resource_facts"]] == [ + "ALIYUN::ECS::RunCommand", + "ALIYUN::VPC::SnatEntry", + ] + assert {signal["resource_type"] for signal in chunks[0]["rule_signals"]} == { + "ALIYUN::ECS::RunCommand", + "ALIYUN::VPC::SnatEntry", + } + + +def test_actionable_only_chunking_filters_full_facts_to_selected_signal_categories() -> None: + module = _load_script_module() + payload = _facts_payload() + payload["resource_facts"].append( + { + "resource_type": "ALIYUN::ECS::Instance", + "product_code": "ecs", + "source_state": "api+local", + "name": {"zh": "ECS 实例", "en": "ECS instance"}, + "description": "Primary compute resource.", + "properties": {}, + "related_properties": {}, + "main_resource_type": None, + "fixed_rule_hits": [], + } + ) + payload["rule_signals"].append( + { + "category": "display", + "resource_type": "ALIYUN::ECS::Instance", + "property_name": None, + "target_resource_types": [], + "confidence": "low", + "evidence": ["display only"], + "suggested_patch": {}, + } + ) + + chunks = module.chunk_resource_facts( + payload, + max_facts_per_chunk=10, + mode="global", + actionable_only=True, + signal_categories=("attachment",), + ) + + assert len(chunks) == 1 + assert [fact["resource_type"] for fact in chunks[0]["resource_facts"]] == ["ALIYUN::VPC::SnatEntry"] + assert {signal["category"] for signal in chunks[0]["rule_signals"]} == {"attachment"} + + +def test_actionable_only_chunking_can_filter_by_signal_confidence() -> None: + module = _load_script_module() + + chunks = module.chunk_resource_facts( + _facts_payload(), + max_facts_per_chunk=10, + mode="global", + actionable_only=True, + signal_categories=("attachment", "orchestration_action"), + signal_confidences=("high",), + ) + + assert len(chunks) == 1 + assert [fact["resource_type"] for fact in chunks[0]["resource_facts"]] == ["ALIYUN::ECS::RunCommand"] + assert {signal["confidence"] for signal in chunks[0]["rule_signals"]} == {"high"} + + +def test_run_summary_records_llm_filter_scope(tmp_path: Path) -> None: + module = _load_script_module() + calls: list[str] = [] + + async def fake_llm(prompt: str) -> str: + calls.append(prompt) + return json.dumps({"draft_rules": []}) + + result = module.run_draft_generation_from_facts_payload( + _facts_payload(), + cache_path=tmp_path / "cache.json", + max_facts_per_chunk=10, + chunk_mode="global", + actionable_only=True, + signal_categories=("orchestration_action",), + complete_chunk=fake_llm, + ) + + assert result["summary"]["input_resource_facts"] == 2 + assert result["summary"]["llm_resource_facts"] == 1 + assert result["summary"]["signal_categories"] == ["orchestration_action"] + assert len(calls) == 1 + assert "ALIYUN::ECS::RunCommand" in calls[0] + assert "ALIYUN::VPC::SnatEntry" not in calls[0] + + +def test_prompt_compacts_long_descriptions_before_llm_call() -> None: + module = _load_script_module() + chunk = module.chunk_resource_facts(_facts_payload(), max_facts_per_chunk=2, mode="global")[0] + chunk["resource_facts"][0]["properties"]["HugeProperty"] = { + "description": "x" * 1000, + "related_targets": [], + "required": False, + "type": "string", + } + + prompt = module.build_draft_rules_prompt(chunk) + + assert "x" * 500 not in prompt + assert "HugeProperty" in prompt + assert '"property_names"' in prompt + + +def test_prompt_requests_bilingual_labels_and_fingerprint_tracks_prompt_version() -> None: + module = _load_script_module() + chunk = module.chunk_resource_facts(_facts_payload(), max_facts_per_chunk=2, mode="global")[0] + + prompt = module.build_draft_rules_prompt(chunk) + first_fingerprint = module.chunk_fingerprint(chunk) + module.PROMPT_VERSION = "unit-test-new-prompt" + second_fingerprint = module.chunk_fingerprint(chunk) + + assert '"zh"' in prompt + assert '"en"' in prompt + assert first_fingerprint != second_fingerprint + + +def test_draft_generation_records_parse_errors_and_continues(tmp_path: Path) -> None: + module = _load_script_module() + + async def bad_llm(_prompt: str) -> str: + return "not json" + + result = module.run_draft_generation_from_facts_payload( + _facts_payload(), + cache_path=tmp_path / "cache.json", + max_facts_per_chunk=1, + chunk_mode="global", + complete_chunk=bad_llm, + ) + + assert result["draft_rules"] == [] + assert result["summary"]["parse_errors"] == 2 + assert {chunk["parse_error"] for chunk in result["summary"]["chunks"]} == { + "LLM output does not contain a JSON object" + } + + +def test_load_existing_draft_result_skips_llm_generation(tmp_path: Path) -> None: + module = _load_script_module() + draft_path = tmp_path / "draft.json" + draft_path.write_text(json.dumps({"summary": {"draft_rules": 0}, "draft_rules": []}), encoding="utf-8") + + result = module.load_existing_draft_result(draft_path) + + assert result == {"summary": {"draft_rules": 0}, "draft_rules": []} + + +def test_filter_draft_result_removes_subagent_rejected_resource_types() -> None: + module = _load_script_module() + result = { + "summary": {"draft_rules": 2}, + "draft_rules": [ + {"resource_type": "ALIYUN::CEN::CenInstanceAttachment"}, + {"resource_type": "ALIYUN::ECS::RunCommand"}, + ], + } + + filtered = module.filter_draft_result(result, reject_resource_types=("ALIYUN::CEN::CenInstanceAttachment",)) + + assert filtered["draft_rules"] == [{"resource_type": "ALIYUN::ECS::RunCommand"}] + assert filtered["summary"]["draft_rules"] == 1 + assert filtered["summary"]["subagent_rejected_resource_types"] == ["ALIYUN::CEN::CenInstanceAttachment"] + + +def test_default_backup_path_is_outside_source_tree() -> None: + module = _load_script_module() + + backup_path = module.default_backup_path() + + assert backup_path.name == "architecture_rules.json.backup" + assert "src/iac_code" not in backup_path.as_posix() + + +def test_summarizes_rule_diff_and_renders_final_report() -> None: + module = _load_script_module() + before = {"compact_child_attachments": [], "compact_resource_labels": {"A": "old"}} + after = { + "compact_child_attachments": [{"resource_types": ["ALIYUN::VPC::SnatEntry"]}], + "compact_resource_labels": {"A": "old", "B": "new"}, + } + diff = module.summarize_rules_diff(before, after) + report = module.render_final_report_markdown( + facts_payload=_facts_payload(), + draft_result={"summary": {"draft_rules": 1, "parse_errors": 0}, "draft_rules": [{}]}, + review_markdown="# review\n\n| Accepted | 1 |\n| Rejected | 0 |\n", + diff_summary=diff, + paths={ + "facts": "/tmp/facts.json", + "draft": "/tmp/draft.json", + "review": "/tmp/review.md", + "rules": "/tmp/rules.json", + }, + verification_results=["pytest: pending"], + ) + + assert diff["compact_child_attachments"]["added"] == 1 + assert diff["compact_resource_labels"]["dict_added"] == 1 + assert "LLM 草案数量" in report + assert "`/tmp/rules.json`" in report + assert "compact_child_attachments" in report diff --git a/tests/scripts/test_preview_template_architecture_llm.py b/tests/scripts/test_preview_template_architecture_llm.py new file mode 100644 index 00000000..420f8648 --- /dev/null +++ b/tests/scripts/test_preview_template_architecture_llm.py @@ -0,0 +1,5679 @@ +from __future__ import annotations + +import importlib.util +import json +from pathlib import Path +from types import SimpleNamespace + +import pytest + + +def _load_script_module(): + script_path = Path("scripts/rendering/preview_template_architecture_llm.py") + spec = importlib.util.spec_from_file_location("preview_template_architecture_llm", script_path) + assert spec is not None + assert spec.loader is not None + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +def test_extract_semantic_plan_json_accepts_fenced_json(): + module = _load_script_module() + + result = module.extract_semantic_plan_json( + """```json +{"node_labels":[{"id":"A","label":"App","confidence":"high"}],"edges":[{"from":"A","to":"B","kind":"traffic","label":"traffic","confidence":"high"}]} +```""" + ) + + assert result == { + "node_labels": [{"id": "A", "label": "App", "confidence": "high"}], + "edges": [{"from": "A", "to": "B", "kind": "traffic", "label": "traffic", "confidence": "high"}], + } + + +def test_extract_semantic_plan_json_rejects_missing_json_object(): + module = _load_script_module() + + with pytest.raises(ValueError, match="JSON object"): + module.extract_semantic_plan_json("no json here") + + +def test_try_extract_semantic_plan_json_returns_parse_error(): + module = _load_script_module() + + value, error = module.try_extract_semantic_plan_json('{"node_labels": [{"id": "A"') + + assert value is None + assert error is not None + assert "JSON" in error or "delimiter" in error + + +def test_build_semantic_plan_user_prompt_contains_fact_bundle(): + module = _load_script_module() + + prompt = module.build_semantic_plan_user_prompt( + { + "target_language": {"code": "zh", "name": "Chinese"}, + "visible_nodes": [{"id": "ECS"}], + "llm_semantic_plan_schema": { + "node_labels": {"max_label_chars": 32}, + "edges": {"max_label_chars": 18}, + }, + } + ) + + assert "visible_nodes" in prompt + assert "target_language" in prompt + assert "node_labels" in prompt + assert "max_label_chars" in prompt + assert "Return JSON only" in prompt + + +def test_build_llm_architecture_context_slims_facts_and_adds_scaffold(): + module = _load_script_module() + + architecture_context = { + "template_summary": { + "description": "在现有VPC下，创建Kafka集群，包含管理节点与弹性伸缩节点。", + "descriptions": {"zh-cn": "在现有VPC下，创建Kafka集群。", "en": "Deploy a Kafka cluster."}, + }, + "target_language": {"code": "zh", "name": "Chinese"}, + "visible_nodes": [{"id": f"Node{i}", "type": "ALIYUN::ECS::Instance"} for i in range(35)], + "containers": [{"id": "Vpc", "type": "ALIYUN::ECS::VPC"}], + "containment": [{"resource": "Node1", "container": "Vpc"}], + "visible_edges": [{"from": "Node1", "to": "Node2"}], + "explicit_relations": [{"source": "Node1", "target": "Node2"}], + "property_references": [{"source": f"Node{i}", "target": f"Node{i + 1}"} for i in range(80)], + "all_property_references": [{"source": f"Node{i}", "target": f"Node{i + 1}"} for i in range(80)], + "node_label_hints": [{"id": "Node1", "hints": {"Name": "APP01"}}], + "orchestration_actions": [{"source": "Node1", "target": "Node2"}], + "outputs": [{"name": "Endpoint"}], + "llm_semantic_plan_schema": {"node_labels": {"max_label_chars": 32}}, + "semantic_plan": {"accepted_edges": [{"from": "Old", "to": "State"}]}, + "debug_dump": "x" * 1000, + } + + slim = module.build_llm_architecture_context(architecture_context) + + assert "debug_dump" not in slim + assert "semantic_plan" not in slim + assert slim["template_summary"] == architecture_context["template_summary"] + assert slim["visible_nodes"] == architecture_context["visible_nodes"] + assert len(slim["property_references"]) < len(architecture_context["property_references"]) + assert len(slim["all_property_references"]) < len(architecture_context["all_property_references"]) + assert slim["truncation_summary"]["property_references"] == { + "included_count": 48, + "total_count": 80, + "omitted_count": 32, + "truncated": True, + } + assert slim["truncation_summary"]["all_property_references"] == { + "included_count": 64, + "total_count": 80, + "omitted_count": 16, + "truncated": True, + } + assert slim["semantic_plan_scaffold"]["views"][0]["id"] == "overview" + assert len(json.dumps(slim, ensure_ascii=False)) < len(json.dumps(architecture_context, ensure_ascii=False)) + + +def test_build_llm_architecture_context_keeps_network_attachments(): + module = _load_script_module() + + network_attachments = [ + { + "id": "CenVpcAttachment", + "type": "ALIYUN::CEN::CenInstanceAttachment", + "network": "CEN", + "cen": "CenInstance", + "child_instance_type": "VPC", + "child_instance_id": "Vpc", + "child_resource": "Vpc", + "child_resource_type": "ALIYUN::ECS::VPC", + } + ] + slim = module.build_llm_architecture_context( + { + "target_language": {"code": "zh", "name": "Chinese"}, + "visible_nodes": [{"id": "layer_CenInstance_Config", "type": "CONCEPT::Layer::AttachmentSummary"}], + "containers": [ + {"id": "Vpc", "type": "ALIYUN::ECS::VPC"}, + {"id": "CenInstance", "type": "ALIYUN::CEN::CenInstance"}, + ], + "containment": [{"resource": "layer_CenInstance_Config", "container": "CenInstance"}], + "network_attachments": network_attachments, + } + ) + + assert slim["network_attachments"] == network_attachments + + +def test_build_llm_architecture_context_keeps_kubernetes_application_summary(): + module = _load_script_module() + + kubernetes_applications = [ + { + "cluster": "Ack", + "source": "AppHpa", + "kind": "HorizontalPodAutoscaler", + "name": "tea-hpa", + "label": "HPA弹性伸缩", + "template_refs": ["SlsProject"], + } + ] + slim = module.build_llm_architecture_context( + { + "target_language": {"code": "zh", "name": "Chinese"}, + "visible_nodes": [ + {"id": "AckHpaAutoscaling", "type": "CONCEPT::ACK::HpaAutoscaling"}, + {"id": "SlsProject", "type": "ALIYUN::SLS::Project"}, + ], + "kubernetes_applications": kubernetes_applications, + } + ) + + assert slim["kubernetes_applications"] == kubernetes_applications + + +def test_build_llm_architecture_context_recommends_ack_application_detail_view(): + module = _load_script_module() + + slim = module.build_llm_architecture_context( + { + "target_language": {"code": "zh", "name": "Chinese"}, + "visible_nodes": [ + {"id": "AckApplicationWorkload", "type": "CONCEPT::ACK::ApplicationWorkload"}, + {"id": "AckServiceExposure", "type": "CONCEPT::ACK::ServiceExposure"}, + {"id": "AckHpaAutoscaling", "type": "CONCEPT::ACK::HpaAutoscaling"}, + ], + "kubernetes_applications": [{"cluster": "Ack", "source": "AppHpa", "kind": "HorizontalPodAutoscaler"}], + } + ) + + assert any(view["id"] == "detail_app" for view in slim["semantic_plan_scaffold"]["views"]) + + +def test_build_llm_architecture_context_preserves_multi_vswitch_placement_scaffold(): + module = _load_script_module() + + slim = module.build_llm_architecture_context( + { + "target_language": {"code": "zh", "name": "Chinese"}, + "visible_nodes": [ + {"id": "Slb", "type": "ALIYUN::SLB::LoadBalancer", "label": "SLB"}, + {"id": "AppA", "type": "ALIYUN::ECS::InstanceGroup", "label": "ECS group 1"}, + {"id": "AppB", "type": "ALIYUN::ECS::InstanceGroup", "label": "ECS group 2"}, + {"id": "Rds", "type": "ALIYUN::RDS::DBInstance", "label": "RDS"}, + ], + "containers": [ + {"id": "Vpc", "type": "ALIYUN::ECS::VPC", "label": "VPC"}, + {"id": "VSwitchA", "type": "ALIYUN::ECS::VSwitch", "label": "VSwitch A", "parent": "Vpc"}, + {"id": "VSwitchB", "type": "ALIYUN::ECS::VSwitch", "label": "VSwitch B", "parent": "Vpc"}, + ], + "containment": [ + {"resource": "AppA", "container": "VSwitchA"}, + {"resource": "Rds", "container": "VSwitchA"}, + {"resource": "AppB", "container": "VSwitchB"}, + ], + "visible_edges": [ + {"from": "Slb", "to": "AppA"}, + {"from": "Slb", "to": "AppB"}, + {"from": "AppA", "to": "Rds"}, + {"from": "AppB", "to": "Rds"}, + ], + } + ) + + assert slim["placement_summary"]["requires_contained_overview"] is True + assert slim["semantic_plan_scaffold"]["views"][0]["layout"] == "contained" + + +def test_validate_semantic_plan_result_rejects_flat_overview_for_multi_vswitch_placement(): + module = _load_script_module() + + architecture_context = { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "Slb", "type": "ALIYUN::SLB::LoadBalancer"}, + {"id": "AppA", "type": "ALIYUN::ECS::InstanceGroup"}, + {"id": "AppB", "type": "ALIYUN::ECS::InstanceGroup"}, + {"id": "Rds", "type": "ALIYUN::RDS::DBInstance"}, + ], + "containers": [ + {"id": "Vpc", "type": "ALIYUN::ECS::VPC"}, + {"id": "VSwitchA", "type": "ALIYUN::ECS::VSwitch", "parent": "Vpc"}, + {"id": "VSwitchB", "type": "ALIYUN::ECS::VSwitch", "parent": "Vpc"}, + ], + "containment": [ + {"resource": "AppA", "container": "VSwitchA"}, + {"resource": "Rds", "container": "VSwitchA"}, + {"resource": "AppB", "container": "VSwitchB"}, + ], + "visible_edges": [], + } + semantic_plan = { + "node_labels": [], + "edges": [ + {"from": "Slb", "to": "AppA", "kind": "traffic", "label": "后端转发"}, + {"from": "Slb", "to": "AppB", "kind": "traffic", "label": "后端转发"}, + {"from": "AppA", "to": "Rds", "kind": "dependency", "label": "数据库访问"}, + {"from": "AppB", "to": "Rds", "kind": "dependency", "label": "数据库访问"}, + ], + "views": [ + { + "id": "overview", + "layout": "flat", + "nodes": ["Slb", "AppA", "AppB", "Rds"], + "edges": [ + {"from": "Slb", "to": "AppA", "kind": "traffic", "label": "后端转发"}, + {"from": "Slb", "to": "AppB", "kind": "traffic", "label": "后端转发"}, + {"from": "AppA", "to": "Rds", "kind": "dependency", "label": "数据库访问"}, + {"from": "AppB", "to": "Rds", "kind": "dependency", "label": "数据库访问"}, + ], + } + ], + } + + issues = module.validate_semantic_plan_result( + architecture_context, + semantic_plan, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": semantic_plan["edges"], + "rejected_edges": [], + } + }, + ) + + assert any("placement-sensitive overview should use layout=contained" in issue for issue in issues) + + +def test_validate_semantic_plan_result_ignores_edges_covered_by_deterministic_edges(): + module = _load_script_module() + + semantic_plan = { + "node_labels": [], + "edges": [ + {"from": "Database", "to": "DBCluster", "kind": "management", "label": "数据迁移"}, + {"from": "EcsInstance", "to": "DBCluster", "kind": "traffic", "label": "访问验证"}, + ], + "views": [ + { + "id": "overview", + "title": "迁移架构", + "purpose": "展示迁移和验证", + "layout": "flat", + "nodes": ["Database", "DBCluster", "EcsInstance"], + "edges": [ + {"from": "Database", "to": "DBCluster", "kind": "management", "label": "数据迁移"}, + {"from": "EcsInstance", "to": "DBCluster", "kind": "traffic", "label": "访问验证"}, + ], + } + ], + } + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "Database", "type": "ALIYUN::RDS::DBInstance"}, + {"id": "DBCluster", "type": "ALIYUN::POLARDB::DBCluster"}, + {"id": "EcsInstance", "type": "ALIYUN::ECS::Instance"}, + ], + "containers": [], + "visible_edges": [], + }, + semantic_plan, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": [{"from": "EcsInstance", "to": "DBCluster", "kind": "traffic", "label": "访问验证"}], + "rejected_edges": [ + { + "from": "Database", + "to": "DBCluster", + "reason": "covered by deterministic edge", + } + ], + } + }, + ) + + assert not any("Database->DBCluster was rejected" in issue for issue in issues) + + +def test_validate_semantic_plan_result_ignores_edges_covered_by_scaled_concept(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "SeedEcs", "type": "ALIYUN::ECS::Instance"}, + {"id": "ScalingGroup", "type": "ALIYUN::ESS::ScalingGroup"}, + {"id": "ScaledEcs", "type": "CONCEPT::ESS::ScaledECS"}, + ], + "concept_nodes": [ + { + "id": "ScaledEcs", + "type": "CONCEPT::ESS::ScaledECS", + "source": "SeedEcs", + "controller": "ScalingGroup", + } + ], + }, + { + "node_labels": [], + "edges": [{"from": "SeedEcs", "to": "ScalingGroup", "kind": "management", "label": "伸缩配置"}], + }, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": [], + "rejected_edges": [ + { + "from": "SeedEcs", + "to": "ScalingGroup", + "reason": "covered by scaled concept", + } + ], + } + }, + ) + + assert not any("SeedEcs->ScalingGroup was rejected" in issue for issue in issues) + + +def test_repair_semantic_plan_locally_removes_fixable_noise(): + module = _load_script_module() + + architecture_context = { + "visible_nodes": [ + {"id": "Entry", "type": "ALIYUN::ALB::LoadBalancer"}, + {"id": "App", "type": "ALIYUN::ECS::InstanceGroup"}, + {"id": "Db", "type": "ALIYUN::POLARDB::DBCluster"}, + ], + "containers": [{"id": "Vpc", "type": "ALIYUN::ECS::VPC"}], + } + plan = { + "node_labels": [ + {"id": "Entry", "label": "入口", "confidence": "high", "reason": "obvious"}, + {"id": "Missing", "label": "不存在", "confidence": "high", "reason": "bad"}, + ], + "edges": [ + {"from": "Entry", "to": "App", "kind": "traffic", "label": "转发", "confidence": "high"}, + {"from": "App", "to": "Missing", "kind": "traffic", "label": "错误", "confidence": "high"}, + ], + "views": [ + { + "id": "detail_app", + "layout": "deep", + "nodes": ["Entry", "Missing"], + "edges": [{"from": "Entry", "to": "Missing", "kind": "traffic", "label": "错误"}], + }, + { + "id": "overview", + "layout": "contained", + "nodes": ["Entry", "App"], + "edges": [{"from": "Entry", "to": "App", "kind": "traffic", "label": "转发"}], + }, + ], + } + + repaired = module.repair_semantic_plan_locally(architecture_context, plan) + + assert repaired["views"][0]["id"] == "overview" + assert repaired["views"][1]["layout"] == "flat" + assert repaired["node_labels"] == [{"id": "Entry", "label": "入口", "confidence": "high"}] + assert repaired["edges"] == [ + {"from": "Entry", "to": "App", "kind": "traffic", "label": "转发", "confidence": "high"} + ] + assert repaired["views"][1]["nodes"] == ["Entry"] + assert repaired["views"][1]["edges"] == [] + + +def test_repair_semantic_plan_locally_drops_isolated_non_anchor_detail_nodes_when_edges_exist(): + module = _load_script_module() + + architecture_context = { + "visible_nodes": [ + {"id": "App", "type": "ALIYUN::ECS::InstanceGroup"}, + {"id": "Redis", "type": "ALIYUN::REDIS::Instance"}, + {"id": "Topic", "type": "ALIYUN::ROCKETMQ5::Topic"}, + ], + "containers": [], + } + plan = { + "views": [ + { + "id": "overview", + "layout": "flat", + "nodes": ["App", "Redis"], + "edges": [{"from": "App", "to": "Redis", "kind": "dependency", "label": "缓存访问"}], + }, + { + "id": "detail_app", + "layout": "flat", + "anchors": ["App"], + "nodes": ["App", "Redis", "Topic"], + "edges": [{"from": "App", "to": "Redis", "kind": "dependency", "label": "缓存访问"}], + }, + ] + } + + repaired = module.repair_semantic_plan_locally(architecture_context, plan) + + assert repaired["views"][1]["nodes"] == ["App", "Redis"] + + +def test_repair_semantic_plan_locally_completes_detail_edges_from_overview(): + module = _load_script_module() + + architecture_context = { + "visible_nodes": [ + {"id": "IngressEntry", "type": "CONCEPT::Kubernetes::IngressEntry"}, + {"id": "Workload", "type": "CONCEPT::Kubernetes::ApplicationWorkload"}, + {"id": "PostgreSQL", "type": "ALIYUN::RDS::DBInstance"}, + {"id": "Redis", "type": "ALIYUN::REDIS::Instance"}, + {"id": "HelmRelease", "type": "ALIYUN::CS::ClusterHelmApplication"}, + ], + "containers": [], + } + plan = { + "views": [ + { + "id": "overview", + "layout": "flat", + "groups": [ + { + "id": "DataBackendGroup", + "label": "数据后端", + "members": ["PostgreSQL", "Redis"], + } + ], + "nodes": ["IngressEntry", "Workload", "DataBackendGroup"], + "edges": [ + {"from": "IngressEntry", "to": "Workload", "kind": "traffic", "label": "入口流量"}, + {"from": "Workload", "to": "DataBackendGroup", "kind": "traffic", "label": "数据访问"}, + ], + }, + { + "id": "detail_app", + "layout": "flat", + "anchors": ["IngressEntry", "Workload"], + "nodes": ["IngressEntry", "Workload", "HelmRelease"], + "edges": [{"from": "HelmRelease", "to": "Workload", "kind": "management", "label": "工作负载定义"}], + }, + { + "id": "detail_data", + "layout": "flat", + "anchors": ["Workload", "DataBackendGroup"], + "nodes": ["Workload", "PostgreSQL", "HelmRelease"], + "edges": [{"from": "HelmRelease", "to": "PostgreSQL", "kind": "dependency", "label": "配置绑定"}], + }, + ] + } + + repaired = module.repair_semantic_plan_locally(architecture_context, plan) + + detail_app = repaired["views"][1] + assert {"from": "IngressEntry", "to": "Workload", "kind": "traffic", "label": "入口流量"} in detail_app["edges"] + detail_data = repaired["views"][2] + assert {"from": "Workload", "to": "PostgreSQL", "kind": "traffic", "label": "数据访问"} in detail_data["edges"] + + +def test_repair_semantic_plan_locally_completes_overview_edge_for_isolated_selected_node(): + module = _load_script_module() + + node_ids = ["HookIn", "HookOut", "TemplateIn", "TemplateOut", "WorkerGroup", "Role", "MasterGroup"] + architecture_context = { + "visible_nodes": [{"id": node_id, "type": "ALIYUN::OOS::Template"} for node_id in node_ids], + "containers": [], + } + plan = { + "edges": [ + {"from": "HookIn", "to": "WorkerGroup", "kind": "management", "label": "监听扩容"}, + {"from": "HookOut", "to": "WorkerGroup", "kind": "management", "label": "监听缩容"}, + {"from": "HookIn", "to": "TemplateIn", "kind": "management", "label": "触发扩容"}, + {"from": "HookOut", "to": "TemplateOut", "kind": "management", "label": "触发缩容"}, + {"from": "TemplateIn", "to": "Role", "kind": "dependency", "label": "执行授权"}, + {"from": "TemplateOut", "to": "Role", "kind": "dependency", "label": "执行授权"}, + {"from": "TemplateOut", "to": "MasterGroup", "kind": "management", "label": "更新配置"}, + ], + "views": [ + { + "id": "overview", + "layout": "flat", + "nodes": node_ids, + "edges": [ + {"from": "HookIn", "to": "WorkerGroup", "kind": "management", "label": "监听扩容"}, + {"from": "HookOut", "to": "WorkerGroup", "kind": "management", "label": "监听缩容"}, + {"from": "HookIn", "to": "TemplateIn", "kind": "management", "label": "触发扩容"}, + {"from": "HookOut", "to": "TemplateOut", "kind": "management", "label": "触发缩容"}, + {"from": "TemplateIn", "to": "Role", "kind": "dependency", "label": "执行授权"}, + {"from": "TemplateOut", "to": "Role", "kind": "dependency", "label": "执行授权"}, + ], + } + ], + } + + repaired = module.repair_semantic_plan_locally(architecture_context, plan) + + assert { + "from": "TemplateOut", + "to": "MasterGroup", + "kind": "management", + "label": "更新配置", + } in repaired["views"][0]["edges"] + + +def test_repair_semantic_plan_locally_drops_empty_overview_containers(): + module = _load_script_module() + + architecture_context = { + "visible_nodes": [ + {"id": "Role", "type": "ALIYUN::RAM::Role"}, + {"id": "DevEcs", "type": "ALIYUN::ECS::Instance"}, + {"id": "ProdEcs", "type": "ALIYUN::ECS::Instance"}, + ], + "containers": [ + {"id": "DevVpc", "type": "ALIYUN::ECS::VPC", "parent": None}, + {"id": "DevVSwitch", "type": "ALIYUN::ECS::VSwitch", "parent": "DevVpc"}, + {"id": "ProdVpc", "type": "ALIYUN::ECS::VPC", "parent": None}, + {"id": "ProdVSwitch", "type": "ALIYUN::ECS::VSwitch", "parent": "ProdVpc"}, + ], + "containment": [ + {"resource": "DevEcs", "container": "DevVSwitch"}, + {"resource": "ProdEcs", "container": "ProdVSwitch"}, + ], + } + plan = { + "views": [ + { + "id": "overview", + "layout": "contained", + "groups": [{"id": "ComputeGroup", "label": "多环境计算", "members": ["DevEcs", "ProdEcs"]}], + "nodes": ["DevVSwitch", "ProdVSwitch", "Role", "ComputeGroup"], + "edges": [{"from": "Role", "to": "ComputeGroup", "kind": "management", "label": "授权"}], + } + ] + } + + repaired = module.repair_semantic_plan_locally(architecture_context, plan) + + assert repaired["views"][0]["nodes"] == ["Role", "ComputeGroup"] + + +def test_repair_semantic_plan_locally_preserves_placement_overview_layout(): + module = _load_script_module() + + architecture_context = { + "visible_nodes": [ + {"id": "Alb", "type": "ALIYUN::ALB::LoadBalancer"}, + {"id": "App1", "type": "ALIYUN::ECS::InstanceGroup"}, + {"id": "App2", "type": "ALIYUN::ECS::InstanceGroup"}, + ], + "containers": [ + {"id": "Vpc", "type": "ALIYUN::ECS::VPC"}, + {"id": "VSwitch1", "type": "ALIYUN::ECS::VSwitch", "parent": "Vpc"}, + {"id": "VSwitch2", "type": "ALIYUN::ECS::VSwitch", "parent": "Vpc"}, + ], + "containment": [ + {"resource": "Alb", "container": "VSwitch1"}, + {"resource": "App1", "container": "VSwitch1"}, + {"resource": "App2", "container": "VSwitch2"}, + ], + } + plan = { + "views": [ + { + "id": "overview", + "layout": "flat", + "nodes": ["Alb", "App1", "App2"], + "edges": [ + {"from": "Alb", "to": "App1", "kind": "traffic", "label": "流量分发"}, + {"from": "Alb", "to": "App2", "kind": "traffic", "label": "流量分发"}, + ], + } + ] + } + + repaired = module.repair_semantic_plan_locally(architecture_context, plan) + + assert repaired["views"][0]["layout"] == "contained" + + +def test_repair_semantic_plan_locally_normalizes_legacy_perspective_view_ids(): + module = _load_script_module() + + architecture_context = { + "visible_nodes": [ + {"id": "Alb", "type": "ALIYUN::ALB::LoadBalancer"}, + {"id": "App", "type": "ALIYUN::ECS::InstanceGroup"}, + {"id": "Ops", "type": "ALIYUN::ECS::RunCommand"}, + ], + "containers": [], + "containment": [], + } + plan = { + "views": [ + {"id": "overview", "nodes": ["Alb", "App"], "edges": []}, + { + "id": "traffic", + "anchors": ["Alb", "App"], + "nodes": ["Alb", "App"], + "edges": [{"from": "Alb", "to": "App", "kind": "traffic", "label": "流量"}], + }, + { + "id": "operations", + "anchors": ["App"], + "nodes": ["App", "Ops"], + "edges": [{"from": "Ops", "to": "App", "kind": "management", "label": "执行命令"}], + }, + ] + } + + repaired = module.repair_semantic_plan_locally(architecture_context, plan) + + assert [view["id"] for view in repaired["views"]] == ["overview", "detail_app", "detail_operations"] + + +def test_repair_semantic_plan_locally_infers_detail_anchors_from_overview_nodes(): + module = _load_script_module() + + architecture_context = { + "visible_nodes": [ + {"id": "App", "type": "ALIYUN::ECS::InstanceGroup"}, + {"id": "Queue", "type": "ALIYUN::MNS::Queue"}, + {"id": "Command", "type": "ALIYUN::ECS::RunCommand"}, + ], + "containers": [], + "containment": [], + } + plan = { + "views": [ + {"id": "overview", "nodes": ["App", "Queue"], "edges": []}, + { + "id": "operations", + "nodes": ["App", "Command"], + "edges": [{"from": "Command", "to": "App", "kind": "management", "label": "执行命令"}], + }, + ] + } + + repaired = module.repair_semantic_plan_locally(architecture_context, plan) + + detail_operations = repaired["views"][1] + assert detail_operations["id"] == "detail_operations" + assert detail_operations["anchors"] == ["App"] + + +def test_repair_semantic_plan_locally_drops_detail_anchors_not_visible_in_overview(): + module = _load_script_module() + + architecture_context = { + "visible_nodes": [ + {"id": "VpcA", "type": "ALIYUN::ECS::VPC"}, + {"id": "VpcB", "type": "ALIYUN::ECS::VPC"}, + {"id": "TransitRouter", "type": "ALIYUN::CEN::TransitRouter"}, + {"id": "RouteConfigA", "type": "CONCEPT::Layer::AttachmentSummary"}, + {"id": "RouteConfigB", "type": "CONCEPT::Layer::AttachmentSummary"}, + ], + "containers": [], + "containment": [], + } + plan = { + "views": [ + {"id": "overview", "nodes": ["VpcA", "TransitRouter"], "edges": []}, + { + "id": "detail_network", + "anchors": ["VpcA", "VpcB"], + "nodes": ["RouteConfigA", "RouteConfigB", "TransitRouter"], + "edges": [ + {"from": "RouteConfigA", "to": "TransitRouter", "kind": "dependency", "label": "CEN 接入"}, + {"from": "RouteConfigB", "to": "TransitRouter", "kind": "dependency", "label": "CEN 接入"}, + ], + }, + ] + } + + repaired = module.repair_semantic_plan_locally(architecture_context, plan) + + assert repaired["views"][1]["anchors"] == ["VpcA"] + + +def test_repair_semantic_plan_locally_keeps_route_config_edges_out_of_overview_when_detail_exists(): + module = _load_script_module() + + architecture_context = { + "visible_nodes": [ + {"id": "Vpc", "type": "ALIYUN::ECS::VPC"}, + {"id": "TransitRouter", "type": "ALIYUN::CEN::TransitRouter"}, + {"id": "Forwarder", "type": "ALIYUN::ECS::InstanceGroup"}, + {"id": "RouteDomain", "type": "CONCEPT::Layer::AttachmentSummary"}, + ], + "containers": [], + "containment": [], + } + plan = { + "edges": [ + {"from": "Vpc", "to": "TransitRouter", "kind": "dependency", "label": "CEN 接入"}, + {"from": "Forwarder", "to": "TransitRouter", "kind": "traffic", "label": "回程流量"}, + {"from": "RouteDomain", "to": "Forwarder", "kind": "dependency", "label": "默认路由"}, + ], + "views": [ + { + "id": "overview", + "layout": "flat", + "nodes": ["Vpc", "TransitRouter"], + "edges": [{"from": "Vpc", "to": "TransitRouter", "kind": "dependency", "label": "CEN 接入"}], + }, + { + "id": "detail_network", + "anchors": ["Vpc", "TransitRouter"], + "nodes": ["Vpc", "TransitRouter", "RouteDomain", "Forwarder"], + "edges": [{"from": "RouteDomain", "to": "Forwarder", "kind": "dependency", "label": "默认路由"}], + }, + ], + } + + repaired = module.repair_semantic_plan_locally(architecture_context, plan) + + overview = repaired["views"][0] + assert overview["nodes"] == ["Vpc", "TransitRouter", "Forwarder"] + assert all("RouteDomain" not in (edge["from"], edge["to"]) for edge in overview["edges"]) + + +def test_repair_semantic_plan_locally_does_not_expand_selected_overview_group_members(): + module = _load_script_module() + + architecture_context = { + "visible_nodes": [ + {"id": "Alb", "type": "ALIYUN::ALB::LoadBalancer"}, + {"id": "App1", "type": "ALIYUN::ECS::InstanceGroup"}, + {"id": "App2", "type": "ALIYUN::ECS::InstanceGroup"}, + {"id": "Redis", "type": "ALIYUN::REDIS::Instance"}, + ], + "containers": [], + "containment": [], + } + plan = { + "edges": [ + {"from": "Alb", "to": "App1", "kind": "traffic", "label": "转发请求"}, + {"from": "App1", "to": "Redis", "kind": "dependency", "label": "读写缓存"}, + ], + "views": [ + { + "id": "overview", + "nodes": ["Alb", "AppServers", "Redis"], + "groups": [{"id": "AppServers", "label": "应用服务器集群", "members": ["App1", "App2"]}], + "edges": [ + {"from": "Alb", "to": "AppServers", "kind": "traffic", "label": "分发流量"}, + {"from": "AppServers", "to": "Redis", "kind": "dependency", "label": "缓存访问"}, + ], + } + ], + } + + repaired = module.repair_semantic_plan_locally(architecture_context, plan) + + overview = repaired["views"][0] + assert overview["nodes"] == ["Alb", "AppServers", "Redis"] + assert all("App1" not in (edge["from"], edge["to"]) for edge in overview["edges"]) + + +def test_repair_semantic_plan_locally_marks_cross_network_detail_edge_labels(): + module = _load_script_module() + + architecture_context = { + "visible_nodes": [ + {"id": "Forwarder", "type": "ALIYUN::ECS::Instance"}, + {"id": "FrontendRouteDomain", "type": "CONCEPT::Layer::AttachmentSummary"}, + {"id": "TransitRouter", "type": "ALIYUN::CEN::TransitRouter"}, + ], + "containers": [ + {"id": "SecurityVpc", "type": "ALIYUN::ECS::VPC"}, + {"id": "FrontendVpc", "type": "ALIYUN::ECS::VPC"}, + {"id": "Cen", "type": "ALIYUN::CEN::CenInstance"}, + ], + "containment": [ + {"resource": "Forwarder", "container": "SecurityVpc"}, + {"resource": "FrontendRouteDomain", "container": "FrontendVpc"}, + {"resource": "TransitRouter", "container": "Cen"}, + ], + "network_attachments": [{"type": "ALIYUN::CEN::TransitRouterVpcAttachment"}], + } + plan = { + "views": [ + { + "id": "overview", + "nodes": ["Forwarder", "TransitRouter"], + "edges": [], + }, + { + "id": "detail_network", + "anchors": ["Forwarder", "TransitRouter"], + "nodes": ["Forwarder", "FrontendRouteDomain", "TransitRouter"], + "edges": [ + { + "from": "Forwarder", + "to": "FrontendRouteDomain", + "kind": "dependency", + "label": "回程路由", + } + ], + }, + ] + } + + repaired = module.repair_semantic_plan_locally(architecture_context, plan) + + detail_network = repaired["views"][1] + assert detail_network["edges"][0]["label"] == "经 CEN 回程路由" + + +def test_repair_semantic_plan_locally_completes_compact_overview_from_top_level_edges(): + module = _load_script_module() + + architecture_context = { + "visible_nodes": [ + {"id": "Bandwidth1", "type": "ALIYUN::CEN::CenBandwidthPackage"}, + {"id": "Bandwidth2", "type": "ALIYUN::CEN::CenBandwidthPackage"}, + {"id": "layer_CenInstance_Config", "type": "CONCEPT::Layer::AttachmentSummary"}, + ], + "containers": [{"id": "CenInstance", "type": "ALIYUN::CEN::CenInstance"}], + "containment": [], + } + plan = { + "edges": [ + {"from": "Bandwidth1", "to": "layer_CenInstance_Config", "kind": "dependency", "label": "关联带宽包"}, + {"from": "Bandwidth2", "to": "layer_CenInstance_Config", "kind": "dependency", "label": "关联带宽包"}, + ], + "views": [ + { + "id": "overview", + "layout": "contained", + "nodes": ["layer_CenInstance_Config"], + "edges": [], + } + ], + } + + repaired = module.repair_semantic_plan_locally(architecture_context, plan) + + assert repaired["views"][0]["nodes"] == ["layer_CenInstance_Config", "Bandwidth1", "Bandwidth2"] + assert repaired["views"][0]["edges"] == [ + {"from": "Bandwidth1", "to": "layer_CenInstance_Config", "kind": "dependency", "label": "关联带宽包"}, + {"from": "Bandwidth2", "to": "layer_CenInstance_Config", "kind": "dependency", "label": "关联带宽包"}, + ] + + +def test_repair_semantic_plan_locally_replaces_noisy_container_overview_with_business_edges(): + module = _load_script_module() + + architecture_context = { + "visible_nodes": [ + {"id": "Alb", "type": "ALIYUN::ALB::LoadBalancer"}, + {"id": "App1", "type": "ALIYUN::ECS::InstanceGroup"}, + {"id": "App2", "type": "ALIYUN::ECS::InstanceGroup"}, + {"id": "Rds", "type": "ALIYUN::RDS::DBInstance"}, + {"id": "Nat", "type": "ALIYUN::VPC::NatGateway"}, + ], + "containers": [ + {"id": "Vpc", "type": "ALIYUN::ECS::VPC"}, + {"id": "VSwitch1", "type": "ALIYUN::ECS::VSwitch", "parent": "Vpc"}, + {"id": "VSwitch2", "type": "ALIYUN::ECS::VSwitch", "parent": "Vpc"}, + {"id": "VSwitch3", "type": "ALIYUN::ECS::VSwitch", "parent": "Vpc"}, + {"id": "VSwitch4", "type": "ALIYUN::ECS::VSwitch", "parent": "Vpc"}, + ], + "containment": [ + {"resource": "Alb", "container": "VSwitch3"}, + {"resource": "App1", "container": "VSwitch1"}, + {"resource": "App2", "container": "VSwitch2"}, + {"resource": "Rds", "container": "VSwitch4"}, + {"resource": "Nat", "container": "VSwitch4"}, + ], + } + plan = { + "edges": [ + {"from": "Alb", "to": "App1", "kind": "traffic", "label": "HTTP 转发"}, + {"from": "Alb", "to": "App2", "kind": "traffic", "label": "HTTP 转发"}, + {"from": "App1", "to": "Rds", "kind": "dependency", "label": "数据库访问"}, + {"from": "App2", "to": "Rds", "kind": "dependency", "label": "数据库访问"}, + {"from": "App1", "to": "Nat", "kind": "traffic", "label": "SNAT 出网"}, + {"from": "App2", "to": "Nat", "kind": "traffic", "label": "SNAT 出网"}, + ], + "views": [ + { + "id": "overview", + "layout": "contained", + "nodes": ["VSwitch1", "VSwitch2", "VSwitch3", "VSwitch4"], + "edges": [ + {"from": "VSwitch3", "to": "VSwitch1", "kind": "traffic", "label": "ALB 转发"}, + {"from": "VSwitch1", "to": "VSwitch4", "kind": "dependency", "label": "DB 访问"}, + ], + }, + { + "id": "detail_app", + "layout": "flat", + "anchors": ["VSwitch3", "VSwitch1", "VSwitch2"], + "nodes": ["Alb", "App1", "App2"], + "edges": [ + {"from": "Alb", "to": "App1", "kind": "traffic", "label": "HTTP 转发"}, + {"from": "Alb", "to": "App2", "kind": "traffic", "label": "HTTP 转发"}, + ], + }, + ], + } + + repaired = module.repair_semantic_plan_locally(architecture_context, plan) + + overview = repaired["views"][0] + assert overview["nodes"] == ["Alb", "App1", "App2", "Rds", "Nat"] + assert all(not node_id.startswith("VSwitch") for node_id in overview["nodes"]) + assert overview["edges"] == [ + {"from": "Alb", "to": "App1", "kind": "traffic", "label": "HTTP 转发"}, + {"from": "Alb", "to": "App2", "kind": "traffic", "label": "HTTP 转发"}, + {"from": "App1", "to": "Rds", "kind": "dependency", "label": "数据库访问"}, + {"from": "App2", "to": "Rds", "kind": "dependency", "label": "数据库访问"}, + {"from": "App1", "to": "Nat", "kind": "traffic", "label": "SNAT 出网"}, + {"from": "App2", "to": "Nat", "kind": "traffic", "label": "SNAT 出网"}, + ] + assert [view["id"] for view in repaired["views"]] == ["overview"] + + +def test_repair_semantic_plan_locally_drops_top_level_container_edges_but_keeps_view_edges(): + module = _load_script_module() + + repaired = module.repair_semantic_plan_locally( + { + "visible_nodes": [{"id": "layer_CenInstance_Config", "type": "CONCEPT::Layer::AttachmentSummary"}], + "containers": [{"id": "Vpc", "type": "ALIYUN::ECS::VPC"}], + }, + { + "node_labels": [], + "edges": [{"from": "Vpc", "to": "layer_CenInstance_Config", "kind": "dependency", "label": "CEN 接入"}], + "views": [ + { + "id": "overview", + "nodes": ["layer_CenInstance_Config"], + "edges": [], + }, + { + "id": "detail_network", + "anchors": ["layer_CenInstance_Config"], + "nodes": ["Vpc", "layer_CenInstance_Config"], + "edges": [ + {"from": "Vpc", "to": "layer_CenInstance_Config", "kind": "dependency", "label": "CEN 接入"} + ], + }, + ], + }, + ) + + assert repaired.get("edges") is None + assert repaired["views"][1]["edges"] == [ + {"from": "Vpc", "to": "layer_CenInstance_Config", "kind": "dependency", "label": "CEN 接入"} + ] + + +def test_repair_semantic_plan_locally_marks_external_cen_network_edge(): + module = _load_script_module() + + repaired = module.repair_semantic_plan_locally( + { + "visible_nodes": [{"id": "layer_CenInstance_Config", "type": "CONCEPT::Layer::AttachmentSummary"}], + "containers": [{"id": "Vpc", "type": "ALIYUN::ECS::VPC"}], + "network_attachments": [ + { + "id": "ExternalVpcAttachment", + "type": "ALIYUN::CEN::CenInstanceAttachment", + "network": "CEN", + "child_instance_type": "VPC", + "child_instance_id": "Ref:OtherVpcId", + }, + { + "id": "ExternalVbrAttachment", + "type": "ALIYUN::CEN::CenInstanceAttachment", + "network": "CEN", + "child_instance_type": "VBR", + "child_instance_id": "Ref:OtherVBRId", + }, + { + "id": "CurrentVpcAttachment", + "type": "ALIYUN::CEN::CenInstanceAttachment", + "network": "CEN", + "child_instance_type": "VPC", + "child_resource": "Vpc", + }, + ], + }, + { + "node_labels": [{"id": "layer_CenInstance_Config", "label": "CEN 互联配置", "confidence": "high"}], + "views": [ + { + "id": "overview", + "nodes": ["Vpc"], + "edges": [], + }, + { + "id": "detail_network", + "anchors": ["Vpc"], + "nodes": ["Vpc", "layer_CenInstance_Config"], + "edges": [ + {"from": "Vpc", "to": "layer_CenInstance_Config", "kind": "dependency", "label": "CEN 接入"} + ], + }, + ], + }, + ) + + assert repaired["views"][1]["edges"] == [ + {"from": "Vpc", "to": "layer_CenInstance_Config", "kind": "dependency", "label": "连接外部VPC/VBR"} + ] + + +def test_repair_semantic_plan_locally_marks_external_cen_network_edge_in_small_overview(): + module = _load_script_module() + + repaired = module.repair_semantic_plan_locally( + { + "visible_nodes": [{"id": "layer_CenInstance_Config", "type": "CONCEPT::Layer::AttachmentSummary"}], + "containers": [{"id": "Vpc", "type": "ALIYUN::ECS::VPC"}], + "network_attachments": [ + { + "id": "ExternalVpcAttachment", + "type": "ALIYUN::CEN::CenInstanceAttachment", + "network": "CEN", + "child_instance_type": "VPC", + "child_instance_id": "Ref:OtherVpcId", + }, + { + "id": "ExternalVbrAttachment", + "type": "ALIYUN::CEN::CenInstanceAttachment", + "network": "CEN", + "child_instance_type": "VBR", + "child_instance_id": "Ref:OtherVBRId", + }, + { + "id": "CurrentVpcAttachment", + "type": "ALIYUN::CEN::CenInstanceAttachment", + "network": "CEN", + "child_instance_type": "VPC", + "child_resource": "Vpc", + }, + ], + }, + { + "node_labels": [{"id": "layer_CenInstance_Config", "label": "CEN 互联配置", "confidence": "high"}], + "views": [ + { + "id": "overview", + "nodes": ["Vpc", "layer_CenInstance_Config"], + "edges": [ + {"from": "Vpc", "to": "layer_CenInstance_Config", "kind": "dependency", "label": "CEN 接入"} + ], + } + ], + }, + ) + + assert repaired["views"][0]["edges"] == [ + {"from": "Vpc", "to": "layer_CenInstance_Config", "kind": "dependency", "label": "连接外部VPC/VBR"} + ] + + +def test_repair_semantic_plan_locally_connects_split_route_forwarder_chain(): + module = _load_script_module() + + repaired = module.repair_semantic_plan_locally( + { + "visible_nodes": [ + {"id": "Forwarder", "type": "ALIYUN::ECS::InstanceGroup"}, + {"id": "IngressRouteDomain", "type": "CONCEPT::Layer::AttachmentSummary"}, + {"id": "EgressRouteDomain", "type": "CONCEPT::Layer::AttachmentSummary"}, + {"id": "TransitRouter", "type": "ALIYUN::CEN::TransitRouter"}, + ], + "containers": [], + "network_attachments": [ + { + "id": "VpcAttachment", + "type": "ALIYUN::CEN::TransitRouterVpcAttachment", + "network": "CEN", + "transit_router": "TransitRouter", + "child_instance_type": "VPC", + "child_resource": "VpcSec", + } + ], + "explicit_relations": [ + { + "source": "RouteToForwarder", + "source_type": "ALIYUN::ECS::Route", + "property": "NextHopId", + "target": "Forwarder", + "target_type": "ALIYUN::ECS::InstanceGroup", + }, + { + "source": "RouteToCen", + "source_type": "ALIYUN::ECS::Route", + "property": "NextHopId", + "target": "VpcAttachment", + "target_type": "ALIYUN::CEN::TransitRouterVpcAttachment", + }, + ], + "route_intents": [ + { + "id": "RouteToForwarder", + "type": "ALIYUN::ECS::Route", + "destination": "0.0.0.0/0", + "next_hop_type": "Instance", + "next_hop_resource": "Forwarder", + "next_hop_resource_type": "ALIYUN::ECS::InstanceGroup", + }, + { + "id": "RouteToCen", + "type": "ALIYUN::ECS::Route", + "destination": "0.0.0.0/0", + "next_hop_type": "Attachment", + "next_hop_resource": "VpcAttachment", + "next_hop_resource_type": "ALIYUN::CEN::TransitRouterVpcAttachment", + }, + ], + }, + { + "node_labels": [], + "views": [ + { + "id": "overview", + "layout": "flat", + "nodes": ["Forwarder", "TransitRouter"], + "edges": [{"from": "Forwarder", "to": "TransitRouter", "kind": "dependency", "label": "CEN 接入"}], + }, + { + "id": "detail_network", + "title": "安全 VPC 路由与转发详情", + "layout": "flat", + "anchors": ["Forwarder", "TransitRouter"], + "nodes": ["Forwarder", "IngressRouteDomain", "EgressRouteDomain", "TransitRouter"], + "edges": [ + { + "from": "Forwarder", + "to": "IngressRouteDomain", + "kind": "dependency", + "label": "出网路由下一跳", + }, + { + "from": "EgressRouteDomain", + "to": "TransitRouter", + "kind": "dependency", + "label": "回程路由指向 CEN", + }, + ], + }, + ], + }, + ) + + detail_network = repaired["views"][1] + assert { + "from": "Forwarder", + "to": "EgressRouteDomain", + "kind": "dependency", + "label": "回程路由", + } in detail_network["edges"] + assert module._semantic_view_has_path( + "Forwarder", + {"TransitRouter"}, + detail_network["edges"], + ) + + +def test_repair_semantic_plan_locally_prefers_return_route_over_vpc_container_bridge(): + module = _load_script_module() + + repaired = module.repair_semantic_plan_locally( + { + "visible_nodes": [ + {"id": "Forwarder", "type": "ALIYUN::ECS::InstanceGroup"}, + {"id": "VpcRouteDomain", "type": "CONCEPT::Layer::AttachmentSummary"}, + {"id": "SubnetReturnRoute", "type": "CONCEPT::Layer::AttachmentSummary"}, + {"id": "TransitRouter", "type": "ALIYUN::CEN::TransitRouter"}, + ], + "containers": [{"id": "VpcSec", "type": "ALIYUN::ECS::VPC"}], + "network_attachments": [ + { + "id": "VpcAttachment", + "type": "ALIYUN::CEN::TransitRouterVpcAttachment", + "network": "CEN", + "transit_router": "TransitRouter", + "child_instance_type": "VPC", + "child_resource": "VpcSec", + } + ], + "explicit_relations": [ + { + "source": "RouteToForwarder", + "source_type": "ALIYUN::ECS::Route", + "property": "NextHopId", + "target": "Forwarder", + "target_type": "ALIYUN::ECS::InstanceGroup", + } + ], + }, + { + "node_labels": [], + "views": [ + { + "id": "overview", + "layout": "contained", + "nodes": ["VpcSec", "Forwarder", "TransitRouter"], + "edges": [{"from": "VpcSec", "to": "TransitRouter", "kind": "dependency", "label": "CEN 接入"}], + }, + { + "id": "detail_network", + "title": "安全 VPC 路由与转发详情", + "layout": "flat", + "anchors": ["VpcSec", "Forwarder", "TransitRouter"], + "nodes": ["VpcSec", "Forwarder", "VpcRouteDomain", "SubnetReturnRoute", "TransitRouter"], + "edges": [ + {"from": "VpcSec", "to": "TransitRouter", "kind": "dependency", "label": "CEN 接入"}, + {"from": "VpcRouteDomain", "to": "Forwarder", "kind": "dependency", "label": "下一跳指向"}, + {"from": "VpcSec", "to": "Forwarder", "kind": "traffic", "label": "主路由表转发"}, + {"from": "VpcRouteDomain", "to": "TransitRouter", "kind": "dependency", "label": "出向 CEN"}, + { + "from": "SubnetReturnRoute", + "to": "VpcRouteDomain", + "kind": "dependency", + "label": "关联路由表", + }, + {"from": "Forwarder", "to": "VpcSec", "kind": "traffic", "label": "回程路由"}, + ], + }, + ], + }, + ) + + detail_network = repaired["views"][1] + assert { + "from": "Forwarder", + "to": "SubnetReturnRoute", + "kind": "dependency", + "label": "回程路由", + } in detail_network["edges"] + + +def test_repair_semantic_plan_locally_reverses_detail_network_transit_router_source_edge(): + module = _load_script_module() + + repaired = module.repair_semantic_plan_locally( + { + "visible_nodes": [ + {"id": "TransitRouter", "type": "ALIYUN::CEN::TransitRouter"}, + {"id": "RouteDomain", "type": "CONCEPT::Layer::AttachmentSummary"}, + ], + "containers": [{"id": "VpcSec", "type": "ALIYUN::ECS::VPC"}], + }, + { + "node_labels": [], + "views": [ + { + "id": "overview", + "layout": "contained", + "nodes": ["VpcSec", "TransitRouter"], + "edges": [{"from": "VpcSec", "to": "TransitRouter", "kind": "dependency", "label": "CEN 接入"}], + }, + { + "id": "detail_network", + "layout": "flat", + "anchors": ["VpcSec", "TransitRouter"], + "nodes": ["VpcSec", "TransitRouter", "RouteDomain"], + "edges": [ + {"from": "TransitRouter", "to": "VpcSec", "kind": "traffic", "label": "回程路由"}, + {"from": "RouteDomain", "to": "TransitRouter", "kind": "dependency", "label": "出网路由"}, + ], + }, + ], + }, + ) + + detail_network = repaired["views"][1] + assert { + "from": "VpcSec", + "to": "TransitRouter", + "kind": "dependency", + "label": "CEN 接入", + } in detail_network["edges"] + assert { + "from": "TransitRouter", + "to": "VpcSec", + "kind": "traffic", + "label": "回程路由", + } not in detail_network["edges"] + + +def test_repair_semantic_plan_locally_drops_redundant_small_group_detail_view(): + module = _load_script_module() + + repaired = module.repair_semantic_plan_locally( + { + "visible_nodes": [ + {"id": "LoadBalancer", "type": "ALIYUN::SLB::LoadBalancer"}, + {"id": "BackendServer1", "type": "ALIYUN::ECS::Instance"}, + {"id": "BackendServer2", "type": "ALIYUN::ECS::Instance"}, + {"id": "layer_CenInstance_Config", "type": "CONCEPT::Layer::AttachmentSummary"}, + ], + "containers": [{"id": "Vpc", "type": "ALIYUN::ECS::VPC"}], + }, + { + "node_labels": [], + "edges": [{"from": "LoadBalancer", "to": "BackendGroup", "kind": "traffic", "label": "转发请求"}], + "views": [ + { + "id": "overview", + "layout": "contained", + "groups": [ + { + "id": "BackendGroup", + "label": "后端服务器组", + "members": ["BackendServer1", "BackendServer2"], + "parent": "Vpc", + } + ], + "nodes": ["LoadBalancer", "BackendGroup", "Vpc"], + "edges": [{"from": "LoadBalancer", "to": "BackendGroup", "kind": "traffic", "label": "转发请求"}], + }, + { + "id": "detail_network", + "title": "网络互联详情", + "layout": "flat", + "anchors": ["Vpc"], + "nodes": ["Vpc", "layer_CenInstance_Config"], + "edges": [ + {"from": "Vpc", "to": "layer_CenInstance_Config", "kind": "dependency", "label": "连接外部网络"} + ], + }, + { + "id": "detail_app", + "title": "应用负载详情", + "layout": "flat", + "anchors": ["LoadBalancer", "BackendGroup"], + "nodes": ["LoadBalancer", "BackendServer1", "BackendServer2"], + "edges": [ + {"from": "LoadBalancer", "to": "BackendServer1", "kind": "traffic", "label": "后端转发"}, + {"from": "LoadBalancer", "to": "BackendServer2", "kind": "traffic", "label": "后端转发"}, + ], + }, + ], + }, + ) + + assert [view["id"] for view in repaired["views"]] == ["overview", "detail_network"] + + +def test_repair_semantic_plan_locally_drops_detail_that_repeats_overview_endpoints(): + module = _load_script_module() + + repaired = module.repair_semantic_plan_locally( + { + "visible_nodes": [ + {"id": "DeployTemplate", "type": "ALIYUN::OOS::Template"}, + {"id": "MasterGroup", "type": "ALIYUN::ECS::InstanceGroup"}, + {"id": "LifecycleHook", "type": "ALIYUN::ESS::LifecycleHook"}, + {"id": "WorkerGroup", "type": "ALIYUN::ESS::ScalingGroup"}, + ], + "containers": [], + }, + { + "node_labels": [], + "views": [ + { + "id": "overview", + "title": "Kafka 集群架构概览", + "layout": "flat", + "nodes": ["DeployTemplate", "MasterGroup", "LifecycleHook", "WorkerGroup"], + "edges": [ + {"from": "DeployTemplate", "to": "MasterGroup", "kind": "management", "label": "部署管理节点"}, + {"from": "LifecycleHook", "to": "WorkerGroup", "kind": "management", "label": "触发伸缩事件"}, + ], + }, + { + "id": "detail_operations", + "title": "集群运维与伸缩详情", + "layout": "flat", + "anchors": ["DeployTemplate", "MasterGroup", "LifecycleHook", "WorkerGroup"], + "nodes": ["DeployTemplate", "MasterGroup", "LifecycleHook", "WorkerGroup"], + "edges": [ + {"from": "DeployTemplate", "to": "MasterGroup", "kind": "management", "label": "初始化环境"}, + {"from": "LifecycleHook", "to": "WorkerGroup", "kind": "management", "label": "监听实例状态"}, + ], + }, + ], + }, + ) + + assert [view["id"] for view in repaired["views"]] == ["overview"] + + +def test_repair_semantic_plan_locally_keeps_non_redundant_public_network_app_detail(): + module = _load_script_module() + + repaired = module.repair_semantic_plan_locally( + { + "visible_nodes": [ + {"id": "DmzNlb", "type": "ALIYUN::NLB::LoadBalancer"}, + {"id": "ProdAlb1", "type": "ALIYUN::ALB::LoadBalancer"}, + {"id": "ProdAlb2", "type": "ALIYUN::ALB::LoadBalancer"}, + {"id": "App1", "type": "ALIYUN::ECS::Instance"}, + {"id": "App2", "type": "ALIYUN::ECS::Instance"}, + {"id": "App3", "type": "ALIYUN::ECS::Instance"}, + {"id": "App4", "type": "ALIYUN::ECS::Instance"}, + ], + "containers": [], + }, + { + "node_labels": [], + "edges": [ + {"from": "DmzNlb", "to": "ProdAlbGroup", "kind": "traffic", "label": "经 CEN 后端转发"}, + {"from": "ProdAlbGroup", "to": "ProdAppGroup", "kind": "traffic", "label": "HTTP 转发"}, + ], + "views": [ + { + "id": "overview", + "title": "跨 VPC 负载均衡架构概览", + "layout": "flat", + "groups": [ + {"id": "ProdAlbGroup", "label": "生产 ALB 集群", "members": ["ProdAlb1", "ProdAlb2"]}, + { + "id": "ProdAppGroup", + "label": "生产应用集群", + "members": ["App1", "App2", "App3", "App4"], + }, + ], + "nodes": ["DmzNlb", "ProdAlbGroup", "ProdAppGroup"], + "edges": [ + {"from": "DmzNlb", "to": "ProdAlbGroup", "kind": "traffic", "label": "经 CEN 后端转发"}, + {"from": "ProdAlbGroup", "to": "ProdAppGroup", "kind": "traffic", "label": "HTTP 转发"}, + ], + }, + { + "id": "detail_app", + "title": "生产应用负载分发详情", + "layout": "flat", + "anchors": ["DmzNlb", "ProdAlbGroup", "ProdAppGroup"], + "groups": [ + { + "id": "ProdAppGroup", + "label": "生产应用集群", + "members": ["App1", "App2", "App3", "App4"], + } + ], + "nodes": ["DmzNlb", "ProdAlb1", "ProdAlb2", "ProdAppGroup"], + "edges": [ + {"from": "DmzNlb", "to": "ProdAlb1", "kind": "traffic", "label": "经 CEN 后端转发"}, + {"from": "DmzNlb", "to": "ProdAlb2", "kind": "traffic", "label": "经 CEN 后端转发"}, + {"from": "ProdAlb1", "to": "ProdAppGroup", "kind": "traffic", "label": "HTTP 转发"}, + {"from": "ProdAlb2", "to": "ProdAppGroup", "kind": "traffic", "label": "HTTP 转发"}, + ], + }, + ], + }, + ) + + assert [view["id"] for view in repaired["views"]] == ["overview", "detail_app"] + + +def test_repair_semantic_plan_locally_drops_nat_to_load_balancer_overview_edge(): + module = _load_script_module() + + repaired = module.repair_semantic_plan_locally( + { + "visible_nodes": [ + {"id": "Nlb", "type": "ALIYUN::NLB::LoadBalancer"}, + {"id": "Alb", "type": "ALIYUN::ALB::LoadBalancer"}, + {"id": "App", "type": "ALIYUN::ECS::Instance"}, + {"id": "Nat", "type": "ALIYUN::VPC::NatGateway"}, + {"id": "TransitRouter", "type": "ALIYUN::CEN::TransitRouter"}, + {"id": "DmzRouteConfig", "type": "CONCEPT::Layer::AttachmentSummary"}, + ], + "containers": [], + }, + { + "node_labels": [], + "edges": [ + {"from": "Nlb", "to": "Alb", "kind": "traffic", "label": "经 CEN 转发"}, + {"from": "Alb", "to": "App", "kind": "traffic", "label": "后端转发"}, + {"from": "Nat", "to": "Nlb", "kind": "dependency", "label": "DMZ 出口"}, + ], + "views": [ + { + "id": "overview", + "title": "总览", + "layout": "flat", + "nodes": ["Nlb", "Alb", "App", "Nat"], + "edges": [ + {"from": "Nlb", "to": "Alb", "kind": "traffic", "label": "经 CEN 转发"}, + {"from": "Alb", "to": "App", "kind": "traffic", "label": "后端转发"}, + {"from": "Nat", "to": "Nlb", "kind": "dependency", "label": "DMZ 出口"}, + ], + }, + { + "id": "detail_network", + "title": "网络详情", + "layout": "flat", + "anchors": ["Nlb", "Alb"], + "nodes": ["Nat", "DmzRouteConfig", "TransitRouter"], + "edges": [ + {"from": "Nat", "to": "DmzRouteConfig", "kind": "traffic", "label": "SNAT 路由"}, + {"from": "DmzRouteConfig", "to": "TransitRouter", "kind": "dependency", "label": "CEN 接入"}, + ], + }, + ], + }, + ) + + overview = repaired["views"][0] + assert "Nat" not in overview["nodes"] + assert all({edge.get("from"), edge.get("to")} != {"Nat", "Nlb"} for edge in overview["edges"]) + + +def test_repair_semantic_plan_locally_merges_small_network_detail_into_overview(): + module = _load_script_module() + + repaired = module.repair_semantic_plan_locally( + { + "visible_nodes": [ + {"id": "LoadBalancer", "type": "ALIYUN::SLB::LoadBalancer"}, + {"id": "BackendServer1", "type": "ALIYUN::ECS::Instance"}, + {"id": "BackendServer2", "type": "ALIYUN::ECS::Instance"}, + {"id": "layer_CenInstance_Config", "type": "CONCEPT::Layer::AttachmentSummary"}, + {"id": "CenBandwidthPackage", "type": "ALIYUN::CEN::CenBandwidthPackage"}, + ], + "containers": [{"id": "Vpc", "type": "ALIYUN::ECS::VPC"}], + "network_attachments": [ + { + "id": "ExternalVbrAttachment", + "type": "ALIYUN::CEN::CenInstanceAttachment", + "network": "CEN", + "child_instance_type": "VBR", + "child_instance_id": "Ref:OtherVBRId", + }, + { + "id": "CurrentVpcAttachment", + "type": "ALIYUN::CEN::CenInstanceAttachment", + "network": "CEN", + "child_instance_type": "VPC", + "child_resource": "Vpc", + }, + ], + }, + { + "node_labels": [], + "views": [ + { + "id": "overview", + "layout": "contained", + "groups": [ + { + "id": "BackendGroup", + "label": "后端服务器组", + "members": ["BackendServer1", "BackendServer2"], + "parent": "Vpc", + } + ], + "nodes": ["LoadBalancer", "BackendGroup", "Vpc"], + "edges": [{"from": "LoadBalancer", "to": "BackendGroup", "kind": "traffic", "label": "转发请求"}], + }, + { + "id": "detail_network", + "title": "CEN 互联详情", + "layout": "flat", + "anchors": ["Vpc"], + "nodes": ["Vpc", "layer_CenInstance_Config", "CenBandwidthPackage"], + "edges": [ + { + "from": "Vpc", + "to": "layer_CenInstance_Config", + "kind": "dependency", + "label": "连接外部VPC/VBR", + }, + { + "from": "CenBandwidthPackage", + "to": "layer_CenInstance_Config", + "kind": "management", + "label": "带宽绑定", + }, + ], + }, + ], + }, + ) + + assert [view["id"] for view in repaired["views"]] == ["overview"] + overview = repaired["views"][0] + assert overview["nodes"] == [ + "LoadBalancer", + "BackendGroup", + "Vpc", + "layer_CenInstance_Config", + "CenBandwidthPackage", + ] + assert overview["edges"] == [ + {"from": "LoadBalancer", "to": "BackendGroup", "kind": "traffic", "label": "转发请求"}, + {"from": "Vpc", "to": "layer_CenInstance_Config", "kind": "dependency", "label": "连接外部VPC/VBR"}, + {"from": "CenBandwidthPackage", "to": "layer_CenInstance_Config", "kind": "management", "label": "带宽绑定"}, + ] + + +def test_repair_semantic_plan_locally_merges_small_network_detail_without_expanding_summary_members(): + module = _load_script_module() + + repaired = module.repair_semantic_plan_locally( + { + "visible_nodes": [ + {"id": "LoadBalancer", "type": "ALIYUN::SLB::LoadBalancer"}, + {"id": "BackendServer1", "type": "ALIYUN::ECS::Instance"}, + {"id": "BackendServer2", "type": "ALIYUN::ECS::Instance"}, + {"id": "layer_CenInstance_Config", "type": "CONCEPT::Layer::AttachmentSummary"}, + {"id": "CenBandwidthPackage", "type": "ALIYUN::CEN::CenBandwidthPackage"}, + ], + "containers": [{"id": "Vpc", "type": "ALIYUN::ECS::VPC"}], + "network_attachments": [ + { + "id": "ExternalVbrAttachment", + "type": "ALIYUN::CEN::CenInstanceAttachment", + "network": "CEN", + "child_instance_type": "VBR", + "child_instance_id": "Ref:OtherVBRId", + }, + { + "id": "CurrentVpcAttachment", + "type": "ALIYUN::CEN::CenInstanceAttachment", + "network": "CEN", + "child_instance_type": "VPC", + "child_resource": "Vpc", + }, + ], + }, + { + "node_labels": [], + "views": [ + { + "id": "overview", + "layout": "contained", + "groups": [ + { + "id": "BackendGroup", + "label": "后端服务器组", + "members": ["BackendServer1", "BackendServer2"], + "parent": "Vpc", + }, + { + "id": "CenDomain", + "label": "云企业网互联域", + "members": ["layer_CenInstance_Config", "CenBandwidthPackage"], + }, + ], + "nodes": ["LoadBalancer", "BackendGroup", "Vpc", "CenDomain"], + "edges": [ + {"from": "LoadBalancer", "to": "BackendGroup", "kind": "traffic", "label": "转发请求"}, + {"from": "Vpc", "to": "CenDomain", "kind": "dependency", "label": "跨网互联"}, + ], + }, + { + "id": "detail_network", + "title": "CEN 互联详情", + "layout": "flat", + "anchors": ["Vpc", "CenDomain"], + "nodes": ["Vpc", "layer_CenInstance_Config", "CenBandwidthPackage"], + "edges": [ + { + "from": "layer_CenInstance_Config", + "to": "Vpc", + "kind": "dependency", + "label": "连接外部VPC/VBR", + }, + { + "from": "CenBandwidthPackage", + "to": "layer_CenInstance_Config", + "kind": "management", + "label": "带宽绑定", + }, + ], + }, + ], + }, + ) + + assert [view["id"] for view in repaired["views"]] == ["overview"] + overview = repaired["views"][0] + assert overview["nodes"] == ["LoadBalancer", "BackendGroup", "Vpc", "CenDomain"] + assert overview["edges"] == [ + {"from": "LoadBalancer", "to": "BackendGroup", "kind": "traffic", "label": "转发请求"}, + {"from": "Vpc", "to": "CenDomain", "kind": "dependency", "label": "连接外部VPC/VBR"}, + ] + + +def test_repair_semantic_plan_locally_drops_attachment_marker_repeated_with_layer_summary(): + module = _load_script_module() + + repaired = module.repair_semantic_plan_locally( + { + "visible_nodes": [ + {"id": "layer_CenInstance_Config", "type": "CONCEPT::Layer::AttachmentSummary"}, + {"id": "CenBandwidthPackage", "type": "ALIYUN::CEN::CenBandwidthPackage"}, + ], + "containers": [{"id": "CenInstance", "type": "ALIYUN::CEN::CenInstance"}], + "attachments": [ + { + "via": "CenBandwidthPackageAssociation", + "marker": "CenBandwidthPackage", + "target": "CenInstance", + "property": "CenId", + } + ], + }, + { + "node_labels": [], + "views": [ + { + "id": "overview", + "layout": "contained", + "nodes": ["layer_CenInstance_Config", "CenBandwidthPackage"], + "edges": [ + { + "from": "CenBandwidthPackage", + "to": "layer_CenInstance_Config", + "kind": "management", + "label": "带宽绑定", + } + ], + } + ], + }, + ) + + assert repaired["views"][0]["nodes"] == ["layer_CenInstance_Config"] + assert repaired["views"][0]["edges"] == [] + + +def test_validate_semantic_plan_result_allows_small_cen_network_in_single_overview(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "LoadBalancer", "type": "ALIYUN::SLB::LoadBalancer"}, + {"id": "BackendServer1", "type": "ALIYUN::ECS::Instance"}, + {"id": "BackendServer2", "type": "ALIYUN::ECS::Instance"}, + {"id": "layer_CenInstance_Config", "type": "CONCEPT::Layer::AttachmentSummary"}, + {"id": "CenBandwidthPackage", "type": "ALIYUN::CEN::CenBandwidthPackage"}, + ], + "containers": [{"id": "Vpc", "type": "ALIYUN::ECS::VPC"}], + "network_attachments": [ + { + "id": "ExternalVbrAttachment", + "type": "ALIYUN::CEN::CenInstanceAttachment", + "network": "CEN", + "child_instance_type": "VBR", + "child_instance_id": "Ref:OtherVBRId", + }, + { + "id": "CurrentVpcAttachment", + "type": "ALIYUN::CEN::CenInstanceAttachment", + "network": "CEN", + "child_instance_type": "VPC", + "child_resource": "Vpc", + }, + ], + }, + { + "node_labels": [], + "edges": [{"from": "LoadBalancer", "to": "BackendGroup", "kind": "traffic", "label": "转发请求"}], + "views": [ + { + "id": "overview", + "layout": "contained", + "groups": [ + { + "id": "BackendGroup", + "label": "后端服务器组", + "members": ["BackendServer1", "BackendServer2"], + "parent": "Vpc", + } + ], + "nodes": ["LoadBalancer", "BackendGroup", "Vpc", "layer_CenInstance_Config", "CenBandwidthPackage"], + "edges": [ + {"from": "LoadBalancer", "to": "BackendGroup", "kind": "traffic", "label": "转发请求"}, + { + "from": "Vpc", + "to": "layer_CenInstance_Config", + "kind": "dependency", + "label": "连接外部VPC/VBR", + }, + { + "from": "CenBandwidthPackage", + "to": "layer_CenInstance_Config", + "kind": "management", + "label": "带宽绑定", + }, + ], + } + ], + }, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": [], + "rejected_edges": [], + } + }, + ) + + assert not any("detail_network" in issue for issue in issues) + assert not any("detail_" in issue for issue in issues) + + +def test_retry_policy_stops_after_second_attempt_for_minor_issues(): + module = _load_script_module() + + assert module.should_retry_semantic_plan_attempt(1, 3, ["edge label for A->B is too long: abc"]) is True + assert module.should_retry_semantic_plan_attempt(2, 3, ["edge label for A->B is too long: abc"]) is False + assert ( + module.should_retry_semantic_plan_attempt( + 2, + 3, + ["complex architecture should define overview plus drill-down detail views"], + ) + is True + ) + assert module.should_retry_semantic_plan_attempt(3, 3, ["LLM output was not valid semantic_plan JSON"]) is False + + +def test_retry_policy_treats_isolated_overview_nodes_as_severe(): + module = _load_script_module() + + assert ( + module.should_retry_semantic_plan_attempt( + 2, + 3, + ["view overview has isolated nodes layer_CenInstance_Config; connect them or move them to detail"], + ) + is True + ) + + +def test_validation_issue_score_prefers_fewer_severe_issues(): + module = _load_script_module() + + assert module.validation_issue_score( + ["view overview has isolated nodes layer_CenInstance_Config; connect them or move them to detail"] + ) > module.validation_issue_score(["view detail_network should include anchored network domains BackendGroup"]) + + +def test_build_semantic_plan_user_prompt_includes_retry_feedback(): + module = _load_script_module() + + prompt = module.build_semantic_plan_user_prompt( + {"target_language": {"code": "zh"}, "visible_nodes": [{"id": "ECS"}]}, + previous_plan={"node_labels": [{"id": "ECS", "label": "APP01"}], "edges": []}, + validation_issues=["node label for ECS copies raw identifier APP01"], + ) + + assert "Revise the previous semantic_plan" in prompt + assert "node label for ECS copies raw identifier APP01" in prompt + assert '"label": "APP01"' in prompt + + +def test_build_semantic_plan_user_prompt_keeps_fact_bundle_in_cacheable_prefix(): + module = _load_script_module() + + architecture_context = { + "target_language": {"code": "zh"}, + "visible_nodes": [{"id": "ECS"}, {"id": "RDS"}], + "explicit_relations": [{"source": "ECS", "target": "RDS"}], + } + first_prompt = module.build_semantic_plan_user_prompt(architecture_context) + retry_prompt = module.build_semantic_plan_user_prompt( + architecture_context, + previous_plan={"node_labels": [{"id": "ECS", "label": "APP01"}], "edges": []}, + validation_issues=["node label for ECS copies raw identifier APP01"], + ) + + assert first_prompt.startswith("Architecture fact bundle:\n") + assert retry_prompt.startswith("Architecture fact bundle:\n") + assert module.DYNAMIC_BOUNDARY in first_prompt + assert module.DYNAMIC_BOUNDARY in retry_prompt + assert retry_prompt.index("Validation issues:") > retry_prompt.index(module.DYNAMIC_BOUNDARY) + + common_prefix_chars = 0 + for left, right in zip(first_prompt, retry_prompt): + if left != right: + break + common_prefix_chars += 1 + assert common_prefix_chars > first_prompt.index(module.DYNAMIC_BOUNDARY) + + +def test_build_semantic_plan_user_prompt_can_build_append_retry_instruction_without_facts(): + module = _load_script_module() + + prompt = module.build_semantic_plan_user_prompt( + {"target_language": {"code": "zh"}, "visible_nodes": [{"id": "ECS"}]}, + attempt=2, + validation_issues=["node label for ECS copies raw identifier APP01"], + include_fact_bundle=False, + include_previous_plan=False, + ) + + assert prompt.startswith("Attempt 2 instruction:") + assert "Architecture fact bundle" not in prompt + assert module.DYNAMIC_BOUNDARY not in prompt + assert "Previous semantic_plan" not in prompt + assert "node label for ECS copies raw identifier APP01" in prompt + + +def test_prompt_debug_html_shows_appended_conversation_order(tmp_path): + module = _load_script_module() + + path = tmp_path / "prompt-debug.html" + first_user = ( + "Architecture fact bundle:\n" + '{"visible_nodes":[]}\n\n' + f"{module.DYNAMIC_BOUNDARY}\n\n" + "Attempt 1 instruction:\nCreate a semantic_plan" + ) + module.write_prompt_debug_html( + path, + title="demo.yml", + model="test-model", + records=[ + { + "attempt": 2, + "selected": True, + "llm_seconds": 2.5, + "system_prompt": "SYSTEM ", + "user_prompt": "Attempt 2 instruction:\nRevise the previous semantic_plan", + "messages": [ + {"role": "user", "content": first_user}, + {"role": "assistant", "content": '{"views":[]}'}, + {"role": "user", "content": "Attempt 2 instruction:\nRevise the previous semantic_plan"}, + ], + "sent_validation_issues": ["missing overview"], + "validation_issues": [], + "raw_output": '{"views":[{"id":"overview"}]}', + }, + ], + timings={"llm": 2.5, "total": 3.0}, + ) + + html = path.read_text(encoding="utf-8") + assert "Prompt Sent Order" in html + assert "1. System Prompt" in html + assert "2. User Message 1 Cacheable Prefix" in html + assert "3. Dynamic Boundary" in html + assert "4. User Message 1 Dynamic Instruction" in html + assert "5. Assistant Message 1" in html + assert "6. User Message 2" in html + assert "Full Request Prompt" in html + assert "system:" in html + assert "SYSTEM <rules>" in html + assert "assistant:" in html + assert "{"views":[]}" in html + assert "user:" in html + assert "Attempt 2 instruction:" in html + assert html.index("2. User Message 1 Cacheable Prefix") < html.index("5. Assistant Message 1") + assert html.index("5. Assistant Message 1") < html.index("6. User Message 2") + + +def test_write_prompt_debug_html_contains_attempt_prompts(tmp_path): + module = _load_script_module() + + path = tmp_path / "prompt-debug.html" + module.write_prompt_debug_html( + path, + title="demo.yml", + model="test-model", + records=[ + { + "attempt": 1, + "selected": False, + "llm_seconds": 1.25, + "system_prompt": "SYSTEM ", + "user_prompt": ( + "Architecture fact bundle:\n" + '{"visible_nodes":[]}\n\n' + f"{module.DYNAMIC_BOUNDARY}\n\n" + "Attempt 1 instruction:\nCreate a semantic_plan" + ), + "sent_validation_issues": [], + "validation_issues": ["missing overview"], + "raw_output": '{"views":[]}', + }, + { + "attempt": 2, + "selected": True, + "llm_seconds": 2.5, + "system_prompt": "SYSTEM ", + "user_prompt": ( + "Architecture fact bundle:\n" + '{"visible_nodes":[]}\n\n' + f"{module.DYNAMIC_BOUNDARY}\n\n" + "Attempt 2 instruction:\nRevise the previous semantic_plan" + ), + "sent_validation_issues": ["missing overview"], + "validation_issues": [], + "raw_output": '{"views":[{"id":"overview"}]}', + }, + ], + timings={"llm": 3.75, "total": 4.0}, + ) + + html = path.read_text(encoding="utf-8") + assert "Prompt Debug: demo.yml" in html + assert "test-model" in html + assert "Attempt 1" in html + assert "Attempt 2" in html + assert "selected" in html + assert "SYSTEM <rules>" in html + assert "Create a semantic_plan" in html + assert "missing overview" in html + assert "Prompt Sent Order" in html + assert "Full Request Prompt" in html + assert "1. System Prompt" in html + assert "2. User Message 1 Cacheable Prefix" in html + assert "3. Dynamic Boundary" in html + assert "4. User Message 1 Dynamic Instruction" in html + assert html.index("1. System Prompt") < html.index("2. User Message 1 Cacheable Prefix") + assert html.index("2. User Message 1 Cacheable Prefix") < html.index("3. Dynamic Boundary") + assert html.index("3. Dynamic Boundary") < html.index("4. User Message 1 Dynamic Instruction") + assert module.DYNAMIC_BOUNDARY in html + assert "System Prompt" not in html + assert "Full User Prompt" not in html + assert "Cacheable User Prefix" not in html + assert "Dynamic User Instruction" not in html + assert "Previous Plan Sent" not in html + + +def test_system_prompt_guides_scaled_compute_semantics(): + module = _load_script_module() + + assert "views" in module.SYSTEM_PROMPT + assert "layout" in module.SYSTEM_PROMPT + assert 'layout="flat"' in module.SYSTEM_PROMPT + assert 'layout="contained"' in module.SYSTEM_PROMPT + assert "overview" in module.SYSTEM_PROMPT + assert "drill-down" in module.SYSTEM_PROMPT + assert "anchors" in module.SYSTEM_PROMPT + assert "summary groups" in module.SYSTEM_PROMPT + assert "经 CEN 后端转发" in module.SYSTEM_PROMPT + assert "生产 VPC -> CEN -> DMZ NAT" in module.SYSTEM_PROMPT + assert "detail_app" in module.SYSTEM_PROMPT + assert "Do not create separate peer views named traffic" in module.SYSTEM_PROMPT + assert "property_references" in module.SYSTEM_PROMPT + assert "orchestration_actions" in module.SYSTEM_PROMPT + assert "one orchestration action targets multiple compute resources" in module.SYSTEM_PROMPT + assert "挂载 NAS（云助手）" in module.SYSTEM_PROMPT + assert "concept_nodes" in module.SYSTEM_PROMPT + assert "node_labels" in module.SYSTEM_PROMPT + assert "replace only the main node title" in module.SYSTEM_PROMPT + assert "target_language" in module.SYSTEM_PROMPT + assert "Do not copy raw identifier-like names" in module.SYSTEM_PROMPT + assert "not on the scaling controller" in module.SYSTEM_PROMPT + assert "Route.NextHopId" in module.SYSTEM_PROMPT + assert "route_intents" in module.SYSTEM_PROMPT + assert "安全转发网关 -> 安全子网回程路由 -> CEN 转发路由器" in module.SYSTEM_PROMPT + assert "Avoid repeated fan-in or fan-out edges" in module.SYSTEM_PROMPT + assert "Do not use CEN/Transit Router as the target of business traffic" in module.SYSTEM_PROMPT + assert "NAT Gateway/SNAT is outbound access" in module.SYSTEM_PROMPT + assert "multi-VSwitch architectures" in module.SYSTEM_PROMPT + assert "DMZ VPC 路由配置" in module.SYSTEM_PROMPT + assert "do not make CEN/Transit Router the visual source" in module.SYSTEM_PROMPT + assert "VPC/domain/route summary -> CEN/Transit Router" in module.SYSTEM_PROMPT + assert "Keep route/config domain nodes out of overview" in module.SYSTEM_PROMPT + assert "do not also include CEN/Transit Router as an overview node" in module.SYSTEM_PROMPT + assert "In detail_network, also avoid CEN/Transit Router as a traffic source" in module.SYSTEM_PROMPT + + +def test_validate_semantic_plan_result_flags_raw_identifier_labels_in_chinese(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "node_label_hints": [ + {"id": "App", "hints": {"InstanceName": "APP01"}}, + {"id": "Alb", "hints": {"LoadBalancerName": "ALB_HZ_1"}}, + ], + }, + {"node_labels": [{"id": "App", "label": "APP01"}, {"id": "Alb", "label": "ALB_HZ_1"}], "edges": []}, + { + "semantic_plan": { + "accepted_node_labels": [ + {"id": "App", "label": "APP01"}, + {"id": "Alb", "label": "ALB_HZ_1"}, + ], + "rejected_node_labels": [], + "accepted_edges": [], + "rejected_edges": [], + } + }, + ) + + assert any("APP01" in issue for issue in issues) + assert any("ALB_HZ_1" in issue for issue in issues) + + +def test_validate_semantic_plan_result_accepts_chinese_role_labels(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "node_label_hints": [{"id": "App", "hints": {"InstanceName": "APP01"}}], + }, + {"node_labels": [{"id": "App", "label": "应用服务器 1"}], "edges": []}, + { + "semantic_plan": { + "accepted_node_labels": [{"id": "App", "label": "应用服务器 1"}], + "rejected_node_labels": [], + "accepted_edges": [{"from": "App", "to": "Db", "label": "访问数据库"}], + "rejected_edges": [], + } + }, + ) + + assert issues == [] + + +def test_validate_semantic_plan_result_flags_missing_edges_for_related_architecture(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [{"id": "Alb"}, {"id": "App"}, {"id": "Db"}], + "concept_nodes": [], + "explicit_relations": [ + { + "source": "Alb", + "target": "App", + "source_type": "ALIYUN::ALB::LoadBalancer", + "target_type": "ALIYUN::ECS::InstanceGroup", + }, + { + "source": "App", + "target": "Db", + "source_type": "ALIYUN::ECS::InstanceGroup", + "target_type": "ALIYUN::POLARDB::DBCluster", + }, + ], + }, + {"node_labels": [], "edges": []}, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": [], + "rejected_edges": [], + } + }, + ) + + assert any("semantic_plan has no edges" in issue for issue in issues) + + +def test_validate_semantic_plan_result_accepts_relationships_defined_only_in_views(): + module = _load_script_module() + + semantic_plan = { + "node_labels": [], + "edges": [], + "views": [ + { + "id": "overview", + "layout": "flat", + "nodes": ["LoadBalancer", "BackendGroup"], + "edges": [ + { + "from": "LoadBalancer", + "to": "BackendGroup", + "kind": "traffic", + "label": "后端转发", + } + ], + } + ], + } + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "LoadBalancer", "type": "ALIYUN::SLB::LoadBalancer"}, + {"id": "BackendGroup", "type": "CONCEPT::ApplicationGroup"}, + {"id": "CenConfig", "type": "CONCEPT::Layer::AttachmentSummary"}, + ], + "visible_edges": [{"from": "LoadBalancer", "to": "BackendGroup"}], + "explicit_relations": [ + { + "source": "Attachment", + "target": "LoadBalancer", + "source_type": "ALIYUN::SLB::BackendServerAttachment", + }, + { + "source": "BandwidthPackageAssociation", + "target": "CenConfig", + "source_type": "ALIYUN::CEN::CenBandwidthPackageAssociation", + }, + ], + }, + semantic_plan, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": [], + "rejected_edges": [], + } + }, + ) + + assert not any("semantic_plan has no edges" in issue for issue in issues) + + +def test_validate_semantic_plan_result_rejects_partial_shared_orchestration_dependency(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "App1", "type": "ALIYUN::ECS::InstanceGroup"}, + {"id": "App2", "type": "ALIYUN::ECS::InstanceGroup"}, + {"id": "Redis", "type": "ALIYUN::REDIS::Instance"}, + {"id": "Database", "type": "ALIYUN::POLARDB::DBCluster"}, + ], + "explicit_relations": [], + "orchestration_actions": [ + { + "id": "RunCommand", + "type": "ALIYUN::ECS::RunCommand", + "targets": [ + { + "id": "App1", + "type": "ALIYUN::ECS::InstanceGroup", + "property": "InstanceIds", + "visible": True, + }, + { + "id": "App2", + "type": "ALIYUN::ECS::InstanceGroup", + "property": "InstanceIds", + "visible": True, + }, + ], + "referenced_resources": [ + { + "id": "Redis", + "type": "ALIYUN::REDIS::Instance", + "property": "CommandContent", + "visible": True, + }, + { + "id": "Database", + "type": "ALIYUN::POLARDB::DBCluster", + "property": "CommandContent", + "visible": True, + }, + ], + } + ], + }, + { + "node_labels": [], + "edges": [ + { + "from": "App1", + "to": "Redis", + "kind": "dependency", + "label": "缓存访问", + "confidence": "medium", + } + ], + }, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": [ + { + "from": "App1", + "to": "Redis", + "kind": "dependency", + "label": "缓存访问", + "confidence": "medium", + } + ], + "rejected_edges": [], + } + }, + ) + + assert any("RunCommand shares Redis dependency across App1, App2" in issue for issue in issues) + + +def test_validate_semantic_plan_result_allows_grouped_shared_orchestration_dependency(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "App1", "type": "ALIYUN::ECS::InstanceGroup"}, + {"id": "App2", "type": "ALIYUN::ECS::InstanceGroup"}, + {"id": "Redis", "type": "ALIYUN::REDIS::Instance"}, + ], + "explicit_relations": [], + "orchestration_actions": [ + { + "id": "RunCommand", + "type": "ALIYUN::ECS::RunCommand", + "targets": [ + {"id": "App1", "type": "ALIYUN::ECS::InstanceGroup", "visible": True}, + {"id": "App2", "type": "ALIYUN::ECS::InstanceGroup", "visible": True}, + ], + "referenced_resources": [ + {"id": "Redis", "type": "ALIYUN::REDIS::Instance", "visible": True}, + ], + } + ], + }, + { + "node_labels": [], + "edges": [], + "views": [ + { + "id": "overview", + "title": "应用概览", + "purpose": "overview", + "layout": "flat", + "nodes": ["BackendGroup", "Redis"], + "groups": [{"id": "BackendGroup", "label": "后端服务组", "members": ["App1", "App2"]}], + "edges": [ + { + "from": "BackendGroup", + "to": "Redis", + "kind": "dependency", + "label": "缓存访问", + } + ], + } + ], + }, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": [], + "rejected_edges": [], + } + }, + ) + + assert not any("RunCommand shares Redis dependency" in issue for issue in issues) + + +def test_validate_semantic_plan_result_rejects_partial_shared_dependency_inside_detail_view(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "App1", "type": "ALIYUN::ECS::InstanceGroup"}, + {"id": "App2", "type": "ALIYUN::ECS::InstanceGroup"}, + {"id": "Redis", "type": "ALIYUN::REDIS::Instance"}, + ], + "explicit_relations": [], + "orchestration_actions": [ + { + "id": "RunCommand", + "type": "ALIYUN::ECS::RunCommand", + "targets": [ + {"id": "App1", "type": "ALIYUN::ECS::InstanceGroup", "visible": True}, + {"id": "App2", "type": "ALIYUN::ECS::InstanceGroup", "visible": True}, + ], + "referenced_resources": [ + {"id": "Redis", "type": "ALIYUN::REDIS::Instance", "visible": True}, + ], + } + ], + }, + { + "node_labels": [], + "edges": [], + "views": [ + { + "id": "overview", + "title": "应用概览", + "purpose": "overview", + "layout": "flat", + "nodes": ["BackendGroup", "Redis"], + "groups": [{"id": "BackendGroup", "label": "后端服务组", "members": ["App1", "App2"]}], + "edges": [ + { + "from": "BackendGroup", + "to": "Redis", + "kind": "dependency", + "label": "缓存访问", + } + ], + }, + { + "id": "detail_app", + "title": "应用详情", + "purpose": "detail", + "layout": "flat", + "anchors": ["BackendGroup"], + "nodes": ["App1", "App2", "Redis"], + "edges": [ + { + "from": "App1", + "to": "Redis", + "kind": "dependency", + "label": "缓存访问", + } + ], + }, + ], + }, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": [], + "rejected_edges": [], + } + }, + ) + + assert any("view detail_app partially shows RunCommand dependency Redis" in issue for issue in issues) + + +def test_validate_semantic_plan_result_flags_reversed_scaling_source_edge(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "ScalingGroup", "type": "ALIYUN::ESS::ScalingGroup"}, + {"id": "SeedEcs", "type": "ALIYUN::ECS::Instance"}, + ], + "explicit_relations": [], + }, + { + "node_labels": [], + "edges": [ + { + "from": "ScalingGroup", + "to": "SeedEcs", + "kind": "management", + "label": "基准实例", + "confidence": "high", + } + ], + }, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": [ + { + "from": "ScalingGroup", + "to": "SeedEcs", + "kind": "management", + "label": "基准实例", + "confidence": "high", + } + ], + "rejected_edges": [], + } + }, + ) + + assert any("ESS scaling configuration source" in issue for issue in issues) + + +def test_validate_semantic_plan_result_requires_scaling_configuration_source_edge(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "SeedEcs", "type": "ALIYUN::ECS::Instance"}, + {"id": "ScalingGroup", "type": "ALIYUN::ESS::ScalingGroup"}, + {"id": "ScaledEcs", "type": "CONCEPT::ESS::ScaledECS"}, + ], + "concept_nodes": [ + { + "id": "ScaledEcs", + "type": "CONCEPT::ESS::ScaledECS", + "source": "SeedEcs", + "controller": "ScalingGroup", + "via": "ScalingConfiguration", + } + ], + }, + { + "node_labels": [], + "edges": [{"from": "ScalingGroup", "to": "ScaledEcs", "kind": "management", "label": "弹性伸缩"}], + "views": [ + { + "id": "overview", + "nodes": ["ScalingGroup", "ScaledEcs"], + "edges": [{"from": "ScalingGroup", "to": "ScaledEcs", "kind": "management", "label": "弹性伸缩"}], + } + ], + }, + {"semantic_plan": {"accepted_node_labels": [], "rejected_node_labels": [], "accepted_edges": []}}, + ) + + assert any("ESS scaling configuration source SeedEcs->ScalingGroup" in issue for issue in issues) + + +def test_validate_semantic_plan_result_flags_repeated_fan_in_edges(): + module = _load_script_module() + + accepted_edges = [ + {"from": "User1", "to": "RoleAggregate", "kind": "management", "label": "绑定角色"}, + {"from": "User2", "to": "RoleAggregate", "kind": "management", "label": "绑定角色"}, + {"from": "User3", "to": "RoleAggregate", "kind": "management", "label": "绑定角色"}, + ] + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "User1", "type": "ALIYUN::RAM::User"}, + {"id": "User2", "type": "ALIYUN::RAM::User"}, + {"id": "User3", "type": "ALIYUN::RAM::User"}, + {"id": "RoleAggregate", "type": "ALIYUN::RAM::Role"}, + ], + "explicit_relations": [], + }, + {"node_labels": [], "edges": accepted_edges}, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": accepted_edges, + "rejected_edges": [], + } + }, + ) + + assert any("too many repeated edges to RoleAggregate" in issue for issue in issues) + + +def test_build_llm_architecture_context_prioritizes_ram_governance_scaffold(): + module = _load_script_module() + + context = { + "target_language": {"code": "zh"}, + "resources": [ + {"id": "User1", "type": "ALIYUN::RAM::User"}, + {"id": "User2", "type": "ALIYUN::RAM::User"}, + {"id": "AccessKey1", "type": "ALIYUN::RAM::AccessKey"}, + {"id": "AccessKey2", "type": "ALIYUN::RAM::AccessKey"}, + {"id": "Group1", "type": "ALIYUN::RAM::Group"}, + {"id": "Group2", "type": "ALIYUN::RAM::Group"}, + {"id": "Role1", "type": "ALIYUN::RAM::Role"}, + {"id": "UserToGroup1", "type": "ALIYUN::RAM::UserToGroupAddition"}, + ], + "visible_nodes": [ + {"id": "RamUsers", "type": "ALIYUN::RAM::User", "label": "RAM User x2"}, + {"id": "RamGroups", "type": "ALIYUN::RAM::Group", "label": "RAM Group x2"}, + {"id": "RamRoles", "type": "ALIYUN::RAM::Role", "label": "RAM Role"}, + {"id": "OssBuckets", "type": "ALIYUN::OSS::Bucket", "label": "OSS Bucket x3"}, + {"id": "AppServer", "type": "ALIYUN::ECS::Instance", "label": "ECS Instance"}, + ], + } + + llm_context = module.build_llm_architecture_context(context) + + scaffold_views = llm_context["semantic_plan_scaffold"]["views"] + assert scaffold_views[1]["id"] == "detail_permissions" + assert "governance_summary" in llm_context + assert llm_context["governance_summary"]["primary_intent"] == "identity_and_permission_governance" + + +def test_validate_semantic_plan_result_rejects_ram_governance_as_data_flow(): + module = _load_script_module() + + accepted_edges = [ + {"from": "AppServer", "to": "Database", "kind": "traffic", "label": "数据库访问"}, + {"from": "AppServer", "to": "OssBuckets", "kind": "inferred", "label": "存储访问"}, + {"from": "RamUsers", "to": "AppServer", "kind": "management", "label": "运维管理"}, + ] + semantic_plan = { + "node_labels": [], + "edges": accepted_edges, + "views": [ + { + "id": "overview", + "title": "多环境应用架构概览", + "purpose": "展示应用服务器访问数据库和对象存储", + "layout": "flat", + "nodes": ["RamUsers", "AppServer", "Database", "OssBuckets"], + "edges": accepted_edges, + }, + { + "id": "detail_data", + "title": "数据访问详情", + "purpose": "展开应用数据访问", + "layout": "flat", + "anchors": ["AppServer", "Database", "OssBuckets"], + "nodes": ["AppServer", "Database", "OssBuckets"], + "edges": accepted_edges[:2], + }, + ], + } + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "resources": [ + {"id": "User1", "type": "ALIYUN::RAM::User"}, + {"id": "User2", "type": "ALIYUN::RAM::User"}, + {"id": "AccessKey1", "type": "ALIYUN::RAM::AccessKey"}, + {"id": "AccessKey2", "type": "ALIYUN::RAM::AccessKey"}, + {"id": "Group1", "type": "ALIYUN::RAM::Group"}, + {"id": "Group2", "type": "ALIYUN::RAM::Group"}, + {"id": "Role1", "type": "ALIYUN::RAM::Role"}, + {"id": "UserToGroup1", "type": "ALIYUN::RAM::UserToGroupAddition"}, + ], + "visible_nodes": [ + {"id": "RamUsers", "type": "ALIYUN::RAM::User"}, + {"id": "RamGroups", "type": "ALIYUN::RAM::Group"}, + {"id": "RamRoles", "type": "ALIYUN::RAM::Role"}, + {"id": "OssBuckets", "type": "ALIYUN::OSS::Bucket"}, + {"id": "AppServer", "type": "ALIYUN::ECS::Instance"}, + {"id": "Database", "type": "ALIYUN::RDS::DBInstance"}, + ], + "explicit_relations": [ + { + "source": "AccessKey1", + "source_type": "ALIYUN::RAM::AccessKey", + "target": "User1", + "target_type": "ALIYUN::RAM::User", + "property": "UserName", + }, + { + "source": "UserToGroup1", + "source_type": "ALIYUN::RAM::UserToGroupAddition", + "target": "User1", + "target_type": "ALIYUN::RAM::User", + "property": "Users", + }, + ], + }, + semantic_plan, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": accepted_edges, + "rejected_edges": [], + } + }, + ) + + assert any("RAM-heavy architecture should include detail_permissions" in issue for issue in issues) + assert any("RAM-heavy architecture is dominated by application/data-flow views" in issue for issue in issues) + + +def test_validate_semantic_plan_result_accepts_public_network_drilldown_shape(): + module = _load_script_module() + + semantic_plan = { + "node_labels": [], + "edges": [ + {"from": "DmzNlb", "to": "ProdAlbGroup", "kind": "traffic", "label": "经 CEN 转发"}, + {"from": "ProdAlbGroup", "to": "ProdAppGroup", "kind": "traffic", "label": "HTTP 转发"}, + {"from": "DmzRouteDomain", "to": "TransitRouter", "kind": "management", "label": "CEN 接入"}, + ], + "views": [ + { + "id": "overview", + "title": "多 VPC 互联与流量入口", + "purpose": "展示公网 NLB 到生产应用的主路径", + "layout": "contained", + "groups": [ + {"id": "ProdAlbGroup", "label": "生产 ALB 集群", "members": ["ProdAlb1", "ProdAlb2"]}, + { + "id": "ProdAppGroup", + "label": "生产应用集群", + "members": ["App1", "App2", "App3", "App4"], + }, + ], + "nodes": ["DmzNlb", "ProdAlbGroup", "ProdAppGroup"], + "edges": [ + {"from": "DmzNlb", "to": "ProdAlbGroup", "kind": "traffic", "label": "经 CEN 转发"}, + {"from": "ProdAlbGroup", "to": "ProdAppGroup", "kind": "traffic", "label": "HTTP 转发"}, + ], + }, + { + "id": "detail_app", + "title": "生产应用负载分发详情", + "purpose": "展开 ALB 与后端应用服务器", + "layout": "flat", + "anchors": ["DmzNlb", "ProdAlbGroup", "ProdAppGroup"], + "groups": [ + { + "id": "ProdAppGroup", + "label": "生产应用集群", + "members": ["App1", "App2", "App3", "App4"], + } + ], + "nodes": ["DmzNlb", "ProdAlb1", "ProdAlb2", "ProdAppGroup"], + "edges": [ + {"from": "DmzNlb", "to": "ProdAlb1", "kind": "traffic", "label": "跨 VPC 后端"}, + {"from": "DmzNlb", "to": "ProdAlb2", "kind": "traffic", "label": "跨 VPC 后端"}, + {"from": "ProdAlb1", "to": "ProdAppGroup", "kind": "traffic", "label": "HTTP 转发"}, + {"from": "ProdAlb2", "to": "ProdAppGroup", "kind": "traffic", "label": "HTTP 转发"}, + ], + }, + { + "id": "detail_network", + "title": "CEN 跨域网络互联详情", + "purpose": "展开 CEN 与 DMZ/生产路由域", + "layout": "flat", + "anchors": ["DmzNlb", "ProdAlbGroup"], + "nodes": ["DmzRouteDomain", "ProdRouteDomain1", "ProdRouteDomain2", "TransitRouter"], + "edges": [ + {"from": "DmzRouteDomain", "to": "TransitRouter", "kind": "management", "label": "CEN 接入"}, + {"from": "ProdRouteDomain1", "to": "TransitRouter", "kind": "management", "label": "CEN 接入"}, + {"from": "ProdRouteDomain2", "to": "TransitRouter", "kind": "management", "label": "CEN 接入"}, + ], + }, + ], + } + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "DmzNlb", "type": "ALIYUN::NLB::LoadBalancer"}, + {"id": "ProdAlb1", "type": "ALIYUN::ALB::LoadBalancer"}, + {"id": "ProdAlb2", "type": "ALIYUN::ALB::LoadBalancer"}, + {"id": "App1", "type": "ALIYUN::ECS::Instance"}, + {"id": "App2", "type": "ALIYUN::ECS::Instance"}, + {"id": "App3", "type": "ALIYUN::ECS::Instance"}, + {"id": "App4", "type": "ALIYUN::ECS::Instance"}, + {"id": "TransitRouter", "type": "ALIYUN::CEN::TransitRouter"}, + {"id": "DmzRouteDomain", "type": "CONCEPT::Layer::AttachmentSummary"}, + {"id": "ProdRouteDomain1", "type": "CONCEPT::Layer::AttachmentSummary"}, + {"id": "ProdRouteDomain2", "type": "CONCEPT::Layer::AttachmentSummary"}, + ], + "containers": [ + {"id": "DmzVpc", "type": "ALIYUN::ECS::VPC"}, + {"id": "ProdVpc1", "type": "ALIYUN::ECS::VPC"}, + {"id": "ProdVpc2", "type": "ALIYUN::ECS::VPC"}, + ], + "containment": [ + {"resource": "DmzNlb", "container": "DmzVpc"}, + {"resource": "ProdAlb1", "container": "ProdVpc1"}, + {"resource": "App1", "container": "ProdVpc1"}, + {"resource": "App2", "container": "ProdVpc1"}, + {"resource": "ProdAlb2", "container": "ProdVpc2"}, + {"resource": "App3", "container": "ProdVpc2"}, + {"resource": "App4", "container": "ProdVpc2"}, + ], + "visible_edges": [], + "explicit_relations": [], + }, + semantic_plan, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": semantic_plan["edges"], + "rejected_edges": [], + } + }, + ) + + assert issues == [] + + +def test_validate_semantic_plan_result_rejects_public_network_overview_without_main_relationships(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "DmzNlb", "type": "ALIYUN::NLB::LoadBalancer"}, + {"id": "Nat", "type": "ALIYUN::VPC::NatGateway"}, + {"id": "ProdAlb1", "type": "ALIYUN::ALB::LoadBalancer"}, + {"id": "ProdAlb2", "type": "ALIYUN::ALB::LoadBalancer"}, + {"id": "App1", "type": "ALIYUN::ECS::Instance"}, + {"id": "App2", "type": "ALIYUN::ECS::Instance"}, + {"id": "TransitRouter", "type": "ALIYUN::CEN::TransitRouter"}, + {"id": "DmzRouteDomain", "type": "CONCEPT::Layer::AttachmentSummary"}, + {"id": "ProdRouteDomain1", "type": "CONCEPT::Layer::AttachmentSummary"}, + {"id": "ProdRouteDomain2", "type": "CONCEPT::Layer::AttachmentSummary"}, + ], + "containers": [ + {"id": "DmzVpc", "type": "ALIYUN::ECS::VPC"}, + {"id": "ProdVpc1", "type": "ALIYUN::ECS::VPC"}, + {"id": "ProdVpc2", "type": "ALIYUN::ECS::VPC"}, + ], + "containment": [ + {"resource": "DmzNlb", "container": "DmzVpc"}, + {"resource": "Nat", "container": "DmzVpc"}, + {"resource": "ProdAlb1", "container": "ProdVpc1"}, + {"resource": "App1", "container": "ProdVpc1"}, + {"resource": "ProdAlb2", "container": "ProdVpc2"}, + {"resource": "App2", "container": "ProdVpc2"}, + ], + "network_attachments": [ + { + "type": "ALIYUN::CEN::CenInstanceAttachment", + "child_instance_type": "VPC", + "child_resource": "DmzVpc", + }, + { + "type": "ALIYUN::CEN::CenInstanceAttachment", + "child_instance_type": "VPC", + "child_resource": "ProdVpc1", + }, + { + "type": "ALIYUN::CEN::CenInstanceAttachment", + "child_instance_type": "VPC", + "child_resource": "ProdVpc2", + }, + ], + "visible_edges": [], + "explicit_relations": [], + }, + { + "node_labels": [], + "edges": [ + {"from": "DmzRouteDomain", "to": "TransitRouter", "kind": "dependency", "label": "CEN 接入"}, + {"from": "ProdRouteDomain1", "to": "TransitRouter", "kind": "dependency", "label": "CEN 接入"}, + {"from": "ProdRouteDomain2", "to": "TransitRouter", "kind": "dependency", "label": "CEN 接入"}, + ], + "views": [ + { + "id": "overview", + "title": "跨 VPC 应用架构总览", + "purpose": "展示主路径", + "layout": "contained", + "groups": [ + {"id": "DmzVpcSummary", "label": "DMZ VPC", "members": ["DmzNlb", "Nat"], "parent": "DmzVpc"}, + {"id": "ProdAlbGroup", "label": "生产 ALB 集群", "members": ["ProdAlb1", "ProdAlb2"]}, + ], + "nodes": ["DmzVpcSummary", "ProdAlbGroup"], + "edges": [], + }, + { + "id": "detail_network", + "title": "CEN 互联详情", + "purpose": "展开 CEN 路由", + "layout": "flat", + "anchors": ["DmzVpcSummary", "ProdAlbGroup"], + "nodes": ["DmzVpc", "ProdVpc1", "ProdVpc2", "TransitRouter"], + "edges": [ + {"from": "DmzVpc", "to": "TransitRouter", "kind": "dependency", "label": "CEN 接入"}, + {"from": "ProdVpc1", "to": "TransitRouter", "kind": "dependency", "label": "CEN 接入"}, + {"from": "ProdVpc2", "to": "TransitRouter", "kind": "dependency", "label": "CEN 接入"}, + ], + }, + ], + }, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": [], + "rejected_edges": [], + } + }, + ) + + assert any("view overview has no edges" in issue for issue in issues) + + +def test_validate_semantic_plan_result_requires_detail_app_to_keep_overview_ingress_source(): + module = _load_script_module() + + semantic_plan = { + "node_labels": [], + "edges": [ + {"from": "DmzNlb", "to": "ProdAlbGroup", "kind": "traffic", "label": "经 CEN 后端转发"}, + {"from": "ProdAlbGroup", "to": "ProdAppGroup", "kind": "traffic", "label": "HTTP 转发"}, + ], + "views": [ + { + "id": "overview", + "title": "总览", + "purpose": "展示跨 VPC 入口到生产应用", + "layout": "contained", + "groups": [ + {"id": "ProdAlbGroup", "label": "生产 ALB 集群", "members": ["ProdAlb1", "ProdAlb2"]}, + {"id": "ProdAppGroup", "label": "生产应用集群", "members": ["App1", "App2"]}, + ], + "nodes": ["DmzNlb", "ProdAlbGroup", "ProdAppGroup"], + "edges": [ + {"from": "DmzNlb", "to": "ProdAlbGroup", "kind": "traffic", "label": "经 CEN 后端转发"}, + {"from": "ProdAlbGroup", "to": "ProdAppGroup", "kind": "traffic", "label": "HTTP 转发"}, + ], + }, + { + "id": "detail_app", + "title": "生产应用负载详情", + "purpose": "展开 ALB 与后端", + "layout": "flat", + "anchors": ["ProdAlbGroup", "ProdAppGroup"], + "groups": [{"id": "ProdAppGroup", "label": "生产应用集群", "members": ["App1", "App2"]}], + "nodes": ["ProdAlb1", "ProdAlb2", "ProdAppGroup"], + "edges": [ + {"from": "ProdAlb1", "to": "ProdAppGroup", "kind": "traffic", "label": "HTTP 转发"}, + {"from": "ProdAlb2", "to": "ProdAppGroup", "kind": "traffic", "label": "HTTP 转发"}, + ], + }, + ], + } + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "DmzNlb", "type": "ALIYUN::NLB::LoadBalancer"}, + {"id": "ProdAlb1", "type": "ALIYUN::ALB::LoadBalancer"}, + {"id": "ProdAlb2", "type": "ALIYUN::ALB::LoadBalancer"}, + {"id": "App1", "type": "ALIYUN::ECS::Instance"}, + {"id": "App2", "type": "ALIYUN::ECS::Instance"}, + ], + "containers": [ + {"id": "DmzVpc", "type": "ALIYUN::ECS::VPC"}, + {"id": "ProdVpc1", "type": "ALIYUN::ECS::VPC"}, + {"id": "ProdVpc2", "type": "ALIYUN::ECS::VPC"}, + ], + "containment": [ + {"resource": "DmzNlb", "container": "DmzVpc"}, + {"resource": "ProdAlb1", "container": "ProdVpc1"}, + {"resource": "App1", "container": "ProdVpc1"}, + {"resource": "ProdAlb2", "container": "ProdVpc2"}, + {"resource": "App2", "container": "ProdVpc2"}, + ], + "visible_edges": [], + "explicit_relations": [], + }, + semantic_plan, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": semantic_plan["edges"], + "rejected_edges": [], + } + }, + ) + + assert any("view detail_app should include overview traffic source DmzNlb" in issue for issue in issues) + + +def test_validate_semantic_plan_result_rejects_generic_network_route_domain_labels(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "TransitRouter", "type": "ALIYUN::CEN::TransitRouter"}, + {"id": "DmzRouteConfig", "type": "CONCEPT::Layer::AttachmentSummary", "label": "专有网络 VPC 配置"}, + {"id": "ProdRouteConfig1", "type": "CONCEPT::Layer::AttachmentSummary", "label": "专有网络 VPC 配置"}, + {"id": "ProdRouteConfig2", "type": "CONCEPT::Layer::AttachmentSummary", "label": "专有网络 VPC 配置"}, + ], + "containers": [], + "containment": [], + "visible_edges": [], + "explicit_relations": [], + }, + { + "node_labels": [], + "edges": [], + "views": [ + { + "id": "overview", + "title": "总览", + "purpose": "整体架构", + "layout": "contained", + "nodes": ["TransitRouter"], + "edges": [], + }, + { + "id": "detail_network", + "title": "CEN 互联详情", + "purpose": "展开网络配置", + "layout": "flat", + "anchors": ["TransitRouter"], + "nodes": ["TransitRouter", "DmzRouteConfig", "ProdRouteConfig1", "ProdRouteConfig2"], + "edges": [ + {"from": "DmzRouteConfig", "to": "TransitRouter", "kind": "dependency", "label": "CEN 接入"}, + { + "from": "ProdRouteConfig1", + "to": "TransitRouter", + "kind": "dependency", + "label": "CEN 接入", + }, + { + "from": "ProdRouteConfig2", + "to": "TransitRouter", + "kind": "dependency", + "label": "CEN 接入", + }, + ], + }, + ], + }, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": [], + "rejected_edges": [], + } + }, + ) + + assert any("route/config domain labels should describe purpose" in issue for issue in issues) + + +def test_validate_semantic_plan_result_allows_purposeful_network_route_domain_labels(): + module = _load_script_module() + + semantic_plan = { + "node_labels": [ + {"id": "SecurityRouteConfig", "label": "安全VPC路由域", "confidence": "high"}, + {"id": "FrontendRouteConfig", "label": "前端VPC路由域", "confidence": "high"}, + {"id": "BackendRouteConfig", "label": "后端VPC路由域", "confidence": "high"}, + {"id": "AccessSubnetRouteConfig", "label": "接入子网路由配置", "confidence": "high"}, + {"id": "ManageSubnetRouteConfig", "label": "管理子网路由配置", "confidence": "high"}, + {"id": "GatewaySubnetRouteConfig", "label": "网关子网路由配置", "confidence": "high"}, + ], + "edges": [], + "views": [ + { + "id": "overview", + "title": "总览", + "purpose": "整体架构", + "layout": "flat", + "nodes": ["TransitRouter"], + "edges": [], + }, + { + "id": "detail_network", + "title": "CEN 路由详情", + "purpose": "展开网络路由配置", + "layout": "flat", + "anchors": ["TransitRouter"], + "nodes": [ + "TransitRouter", + "SecurityRouteConfig", + "FrontendRouteConfig", + "BackendRouteConfig", + "AccessSubnetRouteConfig", + "ManageSubnetRouteConfig", + "GatewaySubnetRouteConfig", + ], + "edges": [ + {"from": "SecurityRouteConfig", "to": "TransitRouter", "kind": "management", "label": "CEN 接入"}, + {"from": "FrontendRouteConfig", "to": "TransitRouter", "kind": "management", "label": "CEN 接入"}, + {"from": "BackendRouteConfig", "to": "TransitRouter", "kind": "management", "label": "CEN 接入"}, + ], + }, + ], + } + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "TransitRouter", "type": "ALIYUN::CEN::TransitRouter"}, + *[ + {"id": node_id, "type": "CONCEPT::Layer::AttachmentSummary", "label": "专有网络 VPC 配置"} + for node_id in ( + "SecurityRouteConfig", + "FrontendRouteConfig", + "BackendRouteConfig", + "AccessSubnetRouteConfig", + "ManageSubnetRouteConfig", + "GatewaySubnetRouteConfig", + ) + ], + ], + "containers": [], + "containment": [], + "visible_edges": [], + "explicit_relations": [], + }, + semantic_plan, + { + "semantic_plan": { + "accepted_node_labels": semantic_plan["node_labels"], + "rejected_node_labels": [], + "accepted_edges": [], + "rejected_edges": [], + } + }, + ) + + assert not any("route/config domain labels should describe purpose" in issue for issue in issues) + + +def test_validate_semantic_plan_result_allows_compact_cen_summary_without_detail_network(): + module = _load_script_module() + + semantic_plan = { + "node_labels": [], + "edges": [ + {"from": "Bandwidth1", "to": "layer_CenInstance_Config", "kind": "dependency", "label": "关联带宽包"}, + {"from": "Bandwidth2", "to": "layer_CenInstance_Config", "kind": "dependency", "label": "关联带宽包"}, + ], + "views": [ + { + "id": "overview", + "title": "云企业网互联概览", + "purpose": "展示 CEN 与带宽配置", + "layout": "contained", + "nodes": ["layer_CenInstance_Config", "Bandwidth1", "Bandwidth2"], + "edges": [ + { + "from": "Bandwidth1", + "to": "layer_CenInstance_Config", + "kind": "dependency", + "label": "关联带宽包", + }, + { + "from": "Bandwidth2", + "to": "layer_CenInstance_Config", + "kind": "dependency", + "label": "关联带宽包", + }, + ], + } + ], + } + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "Bandwidth1", "type": "ALIYUN::CEN::CenBandwidthPackage"}, + {"id": "Bandwidth2", "type": "ALIYUN::CEN::CenBandwidthPackage"}, + {"id": "layer_CenInstance_Config", "type": "CONCEPT::Layer::AttachmentSummary"}, + ], + "containers": [{"id": "CenInstance", "type": "ALIYUN::CEN::CenInstance"}], + "containment": [], + "visible_edges": [ + {"from": "Bandwidth1", "to": "layer_CenInstance_Config"}, + {"from": "Bandwidth2", "to": "layer_CenInstance_Config"}, + ], + "network_attachments": [ + {"type": "ALIYUN::CEN::CenInstanceAttachment", "child_instance_type": "VPC", "child_resource": "Vpc1"}, + {"type": "ALIYUN::CEN::CenInstanceAttachment", "child_instance_type": "VPC", "child_resource": "Vpc2"}, + {"type": "ALIYUN::CEN::CenInstanceAttachment", "child_instance_type": "VPC", "child_resource": "Vpc3"}, + {"type": "ALIYUN::CEN::CenInstanceAttachment", "child_instance_type": "VBR", "child_resource": "Vbr1"}, + ], + "explicit_relations": [], + }, + semantic_plan, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": semantic_plan["edges"], + "rejected_edges": [], + } + }, + ) + + assert not any("detail_network" in issue for issue in issues) + + +def test_validate_semantic_plan_result_allows_single_cen_summary_covering_compact_attachments(): + module = _load_script_module() + + semantic_plan = { + "node_labels": [ + {"id": "layer_CenInstance_Config", "label": "CEN 互联与带宽配置", "confidence": "high"}, + ], + "edges": [ + {"from": "Bandwidth1", "to": "layer_CenInstance_Config", "kind": "dependency", "label": "关联带宽包"}, + {"from": "Bandwidth2", "to": "layer_CenInstance_Config", "kind": "dependency", "label": "关联带宽包"}, + ], + "views": [ + { + "id": "overview", + "title": "云企业网互联概览", + "purpose": "展示 CEN 与带宽配置", + "layout": "contained", + "nodes": ["layer_CenInstance_Config"], + "edges": [], + } + ], + } + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "Bandwidth1", "type": "ALIYUN::CEN::CenBandwidthPackage"}, + {"id": "Bandwidth2", "type": "ALIYUN::CEN::CenBandwidthPackage"}, + {"id": "layer_CenInstance_Config", "type": "CONCEPT::Layer::AttachmentSummary"}, + ], + "containers": [{"id": "CenInstance", "type": "ALIYUN::CEN::CenInstance"}], + "containment": [], + "visible_edges": [ + {"from": "Bandwidth1", "to": "layer_CenInstance_Config"}, + {"from": "Bandwidth2", "to": "layer_CenInstance_Config"}, + ], + "attachments": [ + {"marker": "Bandwidth1", "target": "CenInstance"}, + {"marker": "Bandwidth2", "target": "CenInstance"}, + ], + "network_attachments": [ + {"type": "ALIYUN::CEN::CenInstanceAttachment", "child_instance_type": "VPC"}, + {"type": "ALIYUN::CEN::CenInstanceAttachment", "child_instance_type": "VPC"}, + {"type": "ALIYUN::CEN::CenInstanceAttachment", "child_instance_type": "VPC"}, + {"type": "ALIYUN::CEN::CenInstanceAttachment", "child_instance_type": "VBR"}, + ], + "explicit_relations": [], + }, + semantic_plan, + { + "semantic_plan": { + "accepted_node_labels": semantic_plan["node_labels"], + "rejected_node_labels": [], + "accepted_edges": semantic_plan["edges"], + "rejected_edges": [], + } + }, + ) + + assert not any("detail_network" in issue for issue in issues) + + +def test_validate_semantic_plan_result_allows_cen_repeated_vpc_connection_edges(): + module = _load_script_module() + + accepted_edges = [ + {"from": "TransitRouter", "to": "DmzRouteDomain", "kind": "dependency", "label": "VPC 连接"}, + {"from": "TransitRouter", "to": "ProdRouteDomain1", "kind": "dependency", "label": "VPC 连接"}, + {"from": "TransitRouter", "to": "ProdRouteDomain2", "kind": "dependency", "label": "VPC 连接"}, + ] + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "TransitRouter", "type": "ALIYUN::CEN::TransitRouter"}, + {"id": "DmzRouteDomain", "type": "CONCEPT::Layer::AttachmentSummary"}, + {"id": "ProdRouteDomain1", "type": "CONCEPT::Layer::AttachmentSummary"}, + {"id": "ProdRouteDomain2", "type": "CONCEPT::Layer::AttachmentSummary"}, + ], + "explicit_relations": [], + }, + {"node_labels": [], "edges": accepted_edges}, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": accepted_edges, + "rejected_edges": [], + } + }, + ) + + assert not any("too many repeated edges from TransitRouter" in issue for issue in issues) + + +def test_validate_semantic_plan_result_rejects_route_config_domain_nodes_in_overview_when_network_detail_exists(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "TransitRouter", "type": "ALIYUN::CEN::TransitRouter"}, + {"id": "Route1", "type": "ALIYUN::ECS::Route"}, + {"id": "Route2", "type": "ALIYUN::ECS::Route"}, + {"id": "DmzRouteDomain", "type": "CONCEPT::Layer::AttachmentSummary"}, + {"id": "ProdRouteDomain1", "type": "CONCEPT::Layer::AttachmentSummary"}, + {"id": "ProdRouteDomain2", "type": "CONCEPT::Layer::AttachmentSummary"}, + ], + "containers": [], + "containment": [], + "visible_edges": [], + }, + { + "node_labels": [], + "edges": [], + "views": [ + { + "id": "overview", + "title": "总览", + "purpose": "整体架构", + "layout": "contained", + "nodes": ["TransitRouter", "DmzRouteDomain", "ProdRouteDomain1", "ProdRouteDomain2"], + "edges": [ + {"from": "TransitRouter", "to": "DmzRouteDomain", "kind": "dependency", "label": "VPC 连接"}, + { + "from": "TransitRouter", + "to": "ProdRouteDomain1", + "kind": "dependency", + "label": "VPC 连接", + }, + { + "from": "TransitRouter", + "to": "ProdRouteDomain2", + "kind": "dependency", + "label": "VPC 连接", + }, + ], + }, + { + "id": "detail_network", + "title": "网络详情", + "purpose": "展开网络", + "anchors": ["TransitRouter"], + "nodes": ["TransitRouter", "DmzRouteDomain"], + "edges": [ + {"from": "TransitRouter", "to": "DmzRouteDomain", "kind": "dependency", "label": "VPC 连接"} + ], + }, + ], + }, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": [], + "rejected_edges": [], + } + }, + ) + + assert any("view overview includes network route/config detail nodes" in issue for issue in issues) + + +def test_validate_semantic_plan_result_allows_route_config_domain_nodes_in_network_detail(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "TransitRouter", "type": "ALIYUN::CEN::TransitRouter"}, + {"id": "DmzRouteDomain", "type": "CONCEPT::Layer::AttachmentSummary"}, + {"id": "ProdRouteDomain1", "type": "CONCEPT::Layer::AttachmentSummary"}, + {"id": "ProdRouteDomain2", "type": "CONCEPT::Layer::AttachmentSummary"}, + ], + "containers": [], + "containment": [], + "visible_edges": [], + }, + { + "node_labels": [], + "edges": [], + "views": [ + { + "id": "overview", + "title": "总览", + "purpose": "整体架构", + "layout": "contained", + "nodes": ["TransitRouter"], + "edges": [], + }, + { + "id": "detail_network", + "title": "网络详情", + "purpose": "展开网络", + "anchors": ["TransitRouter"], + "nodes": ["TransitRouter", "DmzRouteDomain", "ProdRouteDomain1", "ProdRouteDomain2"], + "edges": [ + {"from": "DmzRouteDomain", "to": "TransitRouter", "kind": "dependency", "label": "CEN 接入"}, + { + "from": "ProdRouteDomain1", + "to": "TransitRouter", + "kind": "dependency", + "label": "CEN 接入", + }, + { + "from": "ProdRouteDomain2", + "to": "TransitRouter", + "kind": "dependency", + "label": "CEN 接入", + }, + ], + }, + ], + }, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": [], + "rejected_edges": [], + } + }, + ) + + assert not any("view detail_network includes network route/config detail nodes" in issue for issue in issues) + + +def test_validate_semantic_plan_result_rejects_cen_as_overview_vpc_connection_source(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "TransitRouter", "type": "ALIYUN::CEN::TransitRouter"}, + {"id": "DmzRouteDomain", "type": "CONCEPT::Layer::AttachmentSummary"}, + ], + "containers": [], + "containment": [], + "visible_edges": [], + }, + { + "node_labels": [], + "edges": [], + "views": [ + { + "id": "overview", + "title": "总览", + "purpose": "整体架构", + "layout": "contained", + "nodes": ["TransitRouter", "DmzRouteDomain"], + "edges": [ + { + "from": "TransitRouter", + "to": "DmzRouteDomain", + "kind": "dependency", + "label": "VPC 互联支撑", + } + ], + } + ], + }, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": [], + "rejected_edges": [], + } + }, + ) + + assert any("makes CEN/TransitRouter the visual source" in issue for issue in issues) + + +def test_validate_semantic_plan_result_allows_vpc_domain_to_cen_connection_direction(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "TransitRouter", "type": "ALIYUN::CEN::TransitRouter"}, + {"id": "DmzRouteDomain", "type": "CONCEPT::Layer::AttachmentSummary"}, + ], + "containers": [], + "containment": [], + "visible_edges": [], + }, + { + "node_labels": [], + "edges": [], + "views": [ + { + "id": "overview", + "title": "总览", + "purpose": "整体架构", + "layout": "contained", + "nodes": ["TransitRouter", "DmzRouteDomain"], + "edges": [ + { + "from": "DmzRouteDomain", + "to": "TransitRouter", + "kind": "dependency", + "label": "CEN 接入", + } + ], + } + ], + }, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": [], + "rejected_edges": [], + } + }, + ) + + assert not any("makes CEN/TransitRouter the visual source" in issue for issue in issues) + + +def test_validate_semantic_plan_result_requires_route_next_hop_compute_on_cen_path(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "TransitRouter", "type": "ALIYUN::CEN::TransitRouter"}, + {"id": "ForwarderGroup", "type": "ALIYUN::ECS::InstanceGroup"}, + {"id": "SubnetRouteDomain", "type": "CONCEPT::Layer::AttachmentSummary"}, + {"id": "VpcRouteDomain", "type": "CONCEPT::Layer::AttachmentSummary"}, + ], + "containers": [], + "containment": [], + "network_attachments": [ + { + "id": "VpcSecAttachment", + "type": "ALIYUN::CEN::TransitRouterVpcAttachment", + "network": "CEN", + "transit_router": "TransitRouter", + "child_instance_type": "VPC", + "child_resource": "VpcSec", + } + ], + "explicit_relations": [ + { + "source": "RouteForwardToEcs", + "target": "ForwarderGroup", + "property": "NextHopId", + "source_type": "ALIYUN::ECS::Route", + "target_type": "ALIYUN::ECS::InstanceGroup", + } + ], + }, + { + "node_labels": [], + "edges": [], + "views": [ + { + "id": "overview", + "title": "总览", + "purpose": "整体架构", + "layout": "contained", + "nodes": ["TransitRouter", "ForwarderGroup"], + "edges": [ + { + "from": "VpcRouteDomain", + "to": "TransitRouter", + "kind": "dependency", + "label": "CEN 接入", + } + ], + }, + { + "id": "detail_network", + "title": "网络详情", + "purpose": "CEN 和安全转发", + "layout": "flat", + "anchors": ["TransitRouter", "ForwarderGroup"], + "nodes": ["TransitRouter", "ForwarderGroup", "SubnetRouteDomain", "VpcRouteDomain"], + "edges": [ + { + "from": "SubnetRouteDomain", + "to": "ForwarderGroup", + "kind": "dependency", + "label": "默认路由", + }, + { + "from": "VpcRouteDomain", + "to": "TransitRouter", + "kind": "dependency", + "label": "CEN 接入", + }, + ], + }, + ], + }, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": [], + "rejected_edges": [], + } + }, + ) + + assert any("route next-hop compute ForwarderGroup" in issue for issue in issues) + + +def test_validate_semantic_plan_result_rejects_overview_cen_node_when_business_edge_mentions_cen(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "Nlb", "type": "ALIYUN::NLB::LoadBalancer"}, + {"id": "Alb", "type": "ALIYUN::ALB::LoadBalancer"}, + {"id": "TransitRouter", "type": "ALIYUN::CEN::TransitRouter"}, + ], + "containers": [], + "containment": [], + "visible_edges": [], + }, + { + "node_labels": [], + "edges": [], + "views": [ + { + "id": "overview", + "title": "总览", + "purpose": "整体架构", + "layout": "contained", + "nodes": ["Nlb", "Alb", "TransitRouter"], + "edges": [ + {"from": "Nlb", "to": "Alb", "kind": "traffic", "label": "经 CEN 后端转发"}, + ], + } + ], + }, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": [], + "rejected_edges": [], + } + }, + ) + + assert any("repeats CEN/TransitRouter both as an overview node and as a traffic label" in issue for issue in issues) + + +def test_validate_semantic_plan_result_flags_unknown_view_nodes(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [{"id": "App", "type": "ALIYUN::ECS::Instance"}], + "containers": [{"id": "Vpc", "type": "ALIYUN::ECS::VPC"}], + "explicit_relations": [], + }, + { + "node_labels": [], + "edges": [], + "views": [ + { + "id": "detail_app", + "title": "业务流量", + "nodes": ["App"], + "edges": [{"from": "App", "to": "MissingNode", "kind": "traffic", "label": "访问"}], + } + ], + }, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": [], + "rejected_edges": [], + } + }, + ) + + assert any("view detail_app references unknown node MissingNode" in issue for issue in issues) + assert any("view detail_app edge App->MissingNode references nodes outside the view" in issue for issue in issues) + + +def test_validate_semantic_plan_result_requires_ack_application_concepts_in_views(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "Ack", "type": "ALIYUN::CS::ManagedKubernetesCluster"}, + {"id": "AckApplicationWorkload", "type": "CONCEPT::ACK::ApplicationWorkload"}, + {"id": "AckHpaAutoscaling", "type": "CONCEPT::ACK::HpaAutoscaling"}, + ], + "containers": [], + "explicit_relations": [], + "kubernetes_applications": [{"cluster": "Ack", "source": "AppHpa", "kind": "HorizontalPodAutoscaler"}], + }, + { + "node_labels": [], + "edges": [ + { + "from": "AckHpaAutoscaling", + "to": "AckApplicationWorkload", + "kind": "management", + "label": "弹性伸缩", + "confidence": "high", + } + ], + "views": [ + { + "id": "overview", + "title": "总览", + "purpose": "整体架构", + "layout": "flat", + "nodes": ["Ack"], + "edges": [], + } + ], + }, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": [ + { + "from": "AckHpaAutoscaling", + "to": "AckApplicationWorkload", + "kind": "management", + "label": "弹性伸缩", + } + ], + "rejected_edges": [], + } + }, + ) + + assert any("ACK/Kubernetes application views should include CONCEPT::ACK nodes" in issue for issue in issues) + + +def test_validate_semantic_plan_result_rejects_ack_cluster_as_application_data_source(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "Ack", "type": "ALIYUN::CS::ManagedKubernetesCluster"}, + {"id": "AckApplicationWorkload", "type": "CONCEPT::ACK::ApplicationWorkload"}, + {"id": "Rds", "type": "ALIYUN::RDS::DBInstance"}, + {"id": "Redis", "type": "ALIYUN::REDIS::Instance"}, + ], + "containers": [], + "explicit_relations": [], + "kubernetes_applications": [ + {"cluster": "Ack", "source": "HelmApp", "kind": "Deployment", "template_refs": ["Rds", "Redis"]} + ], + }, + { + "node_labels": [], + "edges": [ + { + "from": "Ack", + "to": "Rds", + "kind": "traffic", + "label": "数据库访问", + "confidence": "high", + } + ], + "views": [ + { + "id": "overview", + "title": "总览", + "purpose": "整体架构", + "layout": "flat", + "nodes": ["Ack", "Rds", "Redis"], + "edges": [{"from": "Ack", "to": "Rds", "kind": "traffic", "label": "数据库访问"}], + } + ], + }, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": [ + { + "from": "Ack", + "to": "Rds", + "kind": "traffic", + "label": "数据库访问", + } + ], + "rejected_edges": [], + } + }, + ) + + assert any("ACK/Kubernetes runtime data edges should start from application workload" in issue for issue in issues) + + +def test_validate_semantic_plan_result_flags_invalid_view_layout(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [{"id": "App", "type": "ALIYUN::ECS::Instance"}], + "containers": [], + "visible_edges": [], + }, + { + "node_labels": [], + "edges": [], + "views": [ + { + "id": "overview", + "title": "总览", + "purpose": "展示资源", + "layout": "deep", + "nodes": ["App"], + "edges": [], + } + ], + }, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": [], + "rejected_edges": [], + } + }, + ) + + assert any("view overview has invalid layout deep" in issue for issue in issues) + + +def test_validate_semantic_plan_result_flags_complex_architecture_without_views(): + module = _load_script_module() + + visible_nodes = [{"id": f"Node{index}", "type": "ALIYUN::ECS::Instance"} for index in range(1, 13)] + accepted_edges = [ + {"from": f"Node{index}", "to": f"Node{index + 1}", "kind": "traffic", "label": "访问"} for index in range(1, 8) + ] + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": visible_nodes, + "concept_nodes": [], + "explicit_relations": [ + { + "source": edge["from"], + "target": edge["to"], + "source_type": "ALIYUN::ECS::Instance", + "target_type": "ALIYUN::ECS::Instance", + } + for edge in accepted_edges + ], + }, + {"node_labels": [], "edges": accepted_edges}, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": accepted_edges, + "rejected_edges": [], + } + }, + ) + + assert any("complex architecture should define overview plus drill-down detail views" in issue for issue in issues) + + +def test_validate_semantic_plan_result_flags_perspective_views_for_complex_architecture(): + module = _load_script_module() + + visible_nodes = [{"id": f"Node{index}", "type": "ALIYUN::ECS::Instance"} for index in range(1, 13)] + accepted_edges = [ + {"from": f"Node{index}", "to": f"Node{index + 1}", "kind": "traffic", "label": "访问"} for index in range(1, 8) + ] + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": visible_nodes, + "containers": [], + "visible_edges": [], + "explicit_relations": [ + { + "source": edge["from"], + "target": edge["to"], + "source_type": "ALIYUN::ECS::Instance", + "target_type": "ALIYUN::ECS::Instance", + } + for edge in accepted_edges + ], + }, + { + "node_labels": [], + "edges": accepted_edges, + "views": [ + { + "id": "traffic", + "title": "业务流量", + "purpose": "入口到应用", + "nodes": ["Node1", "Node2"], + "edges": [{"from": "Node1", "to": "Node2", "kind": "traffic", "label": "访问"}], + } + ], + }, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": accepted_edges, + "rejected_edges": [], + } + }, + ) + + assert any("views must start with overview" in issue for issue in issues) + assert any("view traffic is a perspective view" in issue for issue in issues) + assert any("at least one detail_" in issue for issue in issues) + + +def test_validate_semantic_plan_result_flags_isolated_overview_nodes(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "Entry", "type": "ALIYUN::ALB::LoadBalancer"}, + {"id": "App", "type": "ALIYUN::ECS::InstanceGroup"}, + {"id": "Nat", "type": "ALIYUN::VPC::NatGateway"}, + ], + "containers": [], + "visible_edges": [], + }, + { + "node_labels": [], + "edges": [{"from": "Entry", "to": "App", "kind": "traffic", "label": "转发"}], + "views": [ + { + "id": "overview", + "title": "总览", + "purpose": "整体架构", + "layout": "flat", + "nodes": ["Entry", "App", "Nat"], + "edges": [{"from": "Entry", "to": "App", "kind": "traffic", "label": "转发"}], + } + ], + }, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": [{"from": "Entry", "to": "App", "kind": "traffic", "label": "转发"}], + "rejected_edges": [], + } + }, + ) + + assert any("view overview has isolated nodes Nat" in issue for issue in issues) + + +def test_validate_semantic_plan_result_flags_missing_network_drilldown_for_network_heavy_architecture(): + module = _load_script_module() + + visible_nodes = [ + {"id": "TransitRouter", "type": "ALIYUN::CEN::TransitRouter"}, + {"id": "VpcAttachment1", "type": "ALIYUN::CEN::TransitRouterVpcAttachment"}, + {"id": "VpcAttachment2", "type": "ALIYUN::CEN::TransitRouterVpcAttachment"}, + {"id": "Route1", "type": "ALIYUN::ECS::Route"}, + {"id": "Route2", "type": "ALIYUN::ECS::Route"}, + {"id": "Nat", "type": "ALIYUN::VPC::NatGateway"}, + {"id": "App1", "type": "ALIYUN::ECS::Instance"}, + {"id": "App2", "type": "ALIYUN::ECS::Instance"}, + {"id": "App3", "type": "ALIYUN::ECS::Instance"}, + {"id": "App4", "type": "ALIYUN::ECS::Instance"}, + {"id": "Alb1", "type": "ALIYUN::ALB::LoadBalancer"}, + {"id": "Alb2", "type": "ALIYUN::ALB::LoadBalancer"}, + ] + accepted_edges = [ + {"from": "Alb1", "to": "App1", "kind": "traffic", "label": "分发"}, + {"from": "Alb1", "to": "App2", "kind": "traffic", "label": "分发"}, + {"from": "Alb2", "to": "App3", "kind": "traffic", "label": "分发"}, + {"from": "Alb2", "to": "App4", "kind": "traffic", "label": "分发"}, + {"from": "TransitRouter", "to": "VpcAttachment1", "kind": "management", "label": "连接"}, + {"from": "TransitRouter", "to": "VpcAttachment2", "kind": "management", "label": "连接"}, + {"from": "Nat", "to": "Route1", "kind": "management", "label": "出口"}, + ] + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": visible_nodes, + "containers": [{"id": "Vpc1", "type": "ALIYUN::ECS::VPC"}, {"id": "Vpc2", "type": "ALIYUN::ECS::VPC"}], + "visible_edges": [], + "explicit_relations": [ + { + "source": edge["from"], + "target": edge["to"], + "source_type": "ALIYUN::ECS::Instance", + "target_type": "ALIYUN::ECS::Instance", + } + for edge in accepted_edges + ], + }, + { + "node_labels": [], + "edges": accepted_edges, + "views": [ + { + "id": "overview", + "title": "总览", + "purpose": "整体架构", + "nodes": ["TransitRouter", "VpcAttachment1", "VpcAttachment2", "Nat"], + "edges": [ + {"from": "TransitRouter", "to": "VpcAttachment1", "kind": "management", "label": "连接"}, + {"from": "TransitRouter", "to": "VpcAttachment2", "kind": "management", "label": "连接"}, + {"from": "Nat", "to": "Route1", "kind": "management", "label": "出口"}, + ], + }, + { + "id": "detail_app", + "title": "应用展开", + "purpose": "应用分发", + "nodes": ["Alb1", "Alb2", "App1", "App2", "App3", "App4"], + "edges": accepted_edges[:4], + }, + ], + }, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": accepted_edges, + "rejected_edges": [], + } + }, + ) + + assert any("network-heavy architecture should include a detail_network" in issue for issue in issues) + + +def test_needs_network_drilldown_for_cen_network_attachments(): + module = _load_script_module() + + assert ( + module._needs_network_drilldown_view( + { + "visible_nodes": [{"id": "layer_CenInstance_Config", "type": "CONCEPT::Layer::AttachmentSummary"}], + "containers": [{"id": "Vpc", "type": "ALIYUN::ECS::VPC"}], + "network_attachments": [ + { + "id": "CurrentVpcAttachment", + "type": "ALIYUN::CEN::CenInstanceAttachment", + "network": "CEN", + "child_instance_type": "VPC", + "child_resource": "Vpc", + }, + { + "id": "ExternalVbrAttachment", + "type": "ALIYUN::CEN::CenInstanceAttachment", + "network": "CEN", + "child_instance_type": "VBR", + "child_instance_id": "Ref:OtherVbrId", + }, + ], + } + ) + is True + ) + + +def test_validate_semantic_plan_result_rejects_contained_network_detail_that_expands_application_container(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "LoadBalancer", "type": "ALIYUN::SLB::LoadBalancer"}, + {"id": "BackendServer1", "type": "ALIYUN::ECS::Instance"}, + {"id": "BackendServer2", "type": "ALIYUN::ECS::Instance"}, + {"id": "layer_CenInstance_Config", "type": "CONCEPT::Layer::AttachmentSummary"}, + ], + "containers": [ + {"id": "Vpc", "type": "ALIYUN::ECS::VPC"}, + {"id": "VSwitch1", "type": "ALIYUN::ECS::VSwitch", "parent": "Vpc"}, + {"id": "VSwitch2", "type": "ALIYUN::ECS::VSwitch", "parent": "Vpc"}, + ], + "containment": [ + {"resource": "BackendServer1", "container": "VSwitch1"}, + {"resource": "BackendServer2", "container": "VSwitch2"}, + ], + "visible_edges": [], + "explicit_relations": [], + "network_attachments": [ + { + "id": "CenVpcAttachment", + "type": "ALIYUN::CEN::CenInstanceAttachment", + "network": "CEN", + "child_instance_type": "VPC", + "child_resource": "Vpc", + } + ], + }, + { + "node_labels": [], + "edges": [{"from": "LoadBalancer", "to": "BackendGroup", "kind": "traffic", "label": "转发"}], + "views": [ + { + "id": "overview", + "title": "总览", + "purpose": "整体架构", + "layout": "contained", + "groups": [ + { + "id": "BackendGroup", + "label": "后端服务器组", + "members": ["BackendServer1", "BackendServer2"], + "parent": "Vpc", + } + ], + "nodes": ["LoadBalancer", "BackendGroup"], + "edges": [{"from": "LoadBalancer", "to": "BackendGroup", "kind": "traffic", "label": "转发"}], + }, + { + "id": "detail_network", + "title": "网络详情", + "purpose": "展开 CEN 接入", + "layout": "contained", + "anchors": ["LoadBalancer"], + "nodes": ["Vpc", "layer_CenInstance_Config"], + "edges": [ + {"from": "Vpc", "to": "layer_CenInstance_Config", "kind": "management", "label": "CEN 接入"} + ], + }, + ], + }, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": [{"from": "LoadBalancer", "to": "BackendGroup", "kind": "traffic", "label": "转发"}], + "rejected_edges": [], + } + }, + ) + + assert any("view detail_network uses contained network containers Vpc" in issue for issue in issues) + + +def test_validate_semantic_plan_result_requires_cen_detail_to_include_attached_child_resource(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "LoadBalancer", "type": "ALIYUN::SLB::LoadBalancer"}, + {"id": "BackendServer1", "type": "ALIYUN::ECS::Instance"}, + {"id": "BackendServer2", "type": "ALIYUN::ECS::Instance"}, + {"id": "CenBandwidthPackage", "type": "ALIYUN::CEN::CenBandwidthPackage"}, + {"id": "layer_CenInstance_Config", "type": "CONCEPT::Layer::AttachmentSummary"}, + ], + "containers": [{"id": "Vpc", "type": "ALIYUN::ECS::VPC"}], + "containment": [ + {"resource": "BackendServer1", "container": "Vpc"}, + {"resource": "BackendServer2", "container": "Vpc"}, + ], + "visible_edges": [{"from": "CenBandwidthPackage", "to": "layer_CenInstance_Config"}], + "explicit_relations": [], + "network_attachments": [ + { + "id": "TheCenVpcAttachment", + "type": "ALIYUN::CEN::CenInstanceAttachment", + "network": "CEN", + "child_instance_type": "VPC", + "child_resource": "Vpc", + "child_resource_type": "ALIYUN::ECS::VPC", + } + ], + }, + { + "node_labels": [], + "edges": [{"from": "LoadBalancer", "to": "BackendGroup", "kind": "traffic", "label": "转发"}], + "views": [ + { + "id": "overview", + "title": "总览", + "purpose": "整体架构", + "layout": "contained", + "groups": [ + { + "id": "BackendGroup", + "label": "后端服务器组", + "members": ["BackendServer1", "BackendServer2"], + "parent": "Vpc", + } + ], + "nodes": ["LoadBalancer", "BackendGroup"], + "edges": [{"from": "LoadBalancer", "to": "BackendGroup", "kind": "traffic", "label": "转发"}], + }, + { + "id": "detail_network", + "title": "CEN 互联详情", + "purpose": "展示 CEN 接入", + "layout": "flat", + "anchors": ["BackendGroup"], + "nodes": ["CenBandwidthPackage", "layer_CenInstance_Config"], + "edges": [ + { + "from": "CenBandwidthPackage", + "to": "layer_CenInstance_Config", + "kind": "dependency", + "label": "绑定带宽包", + } + ], + }, + ], + }, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": [{"from": "LoadBalancer", "to": "BackendGroup", "kind": "traffic", "label": "转发"}], + "rejected_edges": [], + } + }, + ) + + assert any("view detail_network should include CEN attached resources Vpc" in issue for issue in issues) + + +def test_validate_semantic_plan_result_requires_cen_detail_to_explain_external_networks(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "LoadBalancer", "type": "ALIYUN::SLB::LoadBalancer"}, + {"id": "BackendServer1", "type": "ALIYUN::ECS::Instance"}, + {"id": "BackendServer2", "type": "ALIYUN::ECS::Instance"}, + {"id": "CenBandwidthPackage", "type": "ALIYUN::CEN::CenBandwidthPackage"}, + {"id": "layer_CenInstance_Config", "type": "CONCEPT::Layer::AttachmentSummary"}, + ], + "containers": [{"id": "Vpc", "type": "ALIYUN::ECS::VPC"}], + "containment": [ + {"resource": "BackendServer1", "container": "Vpc"}, + {"resource": "BackendServer2", "container": "Vpc"}, + ], + "visible_edges": [{"from": "CenBandwidthPackage", "to": "layer_CenInstance_Config"}], + "explicit_relations": [], + "network_attachments": [ + { + "id": "ExternalVbrAttachment", + "type": "ALIYUN::CEN::CenInstanceAttachment", + "network": "CEN", + "child_instance_type": "VBR", + "child_instance_id": "Ref:OtherVBRId", + }, + { + "id": "ExternalVpcAttachment", + "type": "ALIYUN::CEN::CenInstanceAttachment", + "network": "CEN", + "child_instance_type": "VPC", + "child_instance_id": "Ref:OtherVpcId", + }, + { + "id": "CurrentVpcAttachment", + "type": "ALIYUN::CEN::CenInstanceAttachment", + "network": "CEN", + "child_instance_type": "VPC", + "child_resource": "Vpc", + }, + ], + }, + { + "node_labels": [{"id": "layer_CenInstance_Config", "label": "CEN 互联配置", "confidence": "high"}], + "edges": [{"from": "LoadBalancer", "to": "BackendGroup", "kind": "traffic", "label": "转发"}], + "views": [ + { + "id": "overview", + "title": "总览", + "purpose": "整体架构", + "layout": "contained", + "groups": [ + { + "id": "BackendGroup", + "label": "后端服务器组", + "members": ["BackendServer1", "BackendServer2"], + "parent": "Vpc", + } + ], + "nodes": ["LoadBalancer", "BackendGroup"], + "edges": [{"from": "LoadBalancer", "to": "BackendGroup", "kind": "traffic", "label": "转发"}], + }, + { + "id": "detail_network", + "title": "CEN 互联详情", + "purpose": "展示 CEN 接入", + "layout": "flat", + "anchors": ["BackendGroup"], + "nodes": ["Vpc", "CenBandwidthPackage", "layer_CenInstance_Config"], + "edges": [ + {"from": "Vpc", "to": "layer_CenInstance_Config", "kind": "dependency", "label": "CEN 接入"}, + { + "from": "CenBandwidthPackage", + "to": "layer_CenInstance_Config", + "kind": "dependency", + "label": "带宽包绑定", + }, + ], + }, + ], + }, + { + "semantic_plan": { + "accepted_node_labels": [{"id": "layer_CenInstance_Config", "label": "CEN 互联配置"}], + "rejected_node_labels": [], + "accepted_edges": [{"from": "LoadBalancer", "to": "BackendGroup", "kind": "traffic", "label": "转发"}], + "rejected_edges": [], + } + }, + ) + + assert any("view detail_network should explain external CEN networks" in issue for issue in issues) + + +def test_validate_semantic_plan_result_accepts_cen_detail_that_names_external_networks(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "LoadBalancer", "type": "ALIYUN::SLB::LoadBalancer"}, + {"id": "BackendServer1", "type": "ALIYUN::ECS::Instance"}, + {"id": "BackendServer2", "type": "ALIYUN::ECS::Instance"}, + {"id": "layer_CenInstance_Config", "type": "CONCEPT::Layer::AttachmentSummary"}, + ], + "containers": [{"id": "Vpc", "type": "ALIYUN::ECS::VPC"}], + "containment": [ + {"resource": "BackendServer1", "container": "Vpc"}, + {"resource": "BackendServer2", "container": "Vpc"}, + ], + "visible_edges": [], + "explicit_relations": [], + "network_attachments": [ + { + "id": "ExternalVbrAttachment", + "type": "ALIYUN::CEN::CenInstanceAttachment", + "network": "CEN", + "child_instance_type": "VBR", + "child_instance_id": "Ref:OtherVBRId", + }, + { + "id": "CurrentVpcAttachment", + "type": "ALIYUN::CEN::CenInstanceAttachment", + "network": "CEN", + "child_instance_type": "VPC", + "child_resource": "Vpc", + }, + ], + }, + { + "node_labels": [{"id": "layer_CenInstance_Config", "label": "CEN 互联（外部 VBR）", "confidence": "high"}], + "edges": [{"from": "LoadBalancer", "to": "BackendGroup", "kind": "traffic", "label": "转发"}], + "views": [ + { + "id": "overview", + "layout": "contained", + "groups": [ + { + "id": "BackendGroup", + "label": "后端服务器组", + "members": ["BackendServer1", "BackendServer2"], + "parent": "Vpc", + } + ], + "nodes": ["LoadBalancer", "BackendGroup"], + "edges": [{"from": "LoadBalancer", "to": "BackendGroup", "kind": "traffic", "label": "转发"}], + }, + { + "id": "detail_network", + "title": "CEN 互联详情", + "layout": "flat", + "anchors": ["BackendGroup"], + "nodes": ["Vpc", "layer_CenInstance_Config"], + "edges": [ + { + "from": "Vpc", + "to": "layer_CenInstance_Config", + "kind": "dependency", + "label": "与外部网络互联", + }, + ], + }, + ], + }, + { + "semantic_plan": { + "accepted_node_labels": [{"id": "layer_CenInstance_Config", "label": "CEN 互联（外部 VBR）"}], + "rejected_node_labels": [], + "accepted_edges": [{"from": "LoadBalancer", "to": "BackendGroup", "kind": "traffic", "label": "转发"}], + "rejected_edges": [], + } + }, + ) + + assert not any("view detail_network should explain external CEN networks" in issue for issue in issues) + + +def test_validate_semantic_plan_result_accepts_external_cen_edge_as_cross_network_label(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [{"id": "layer_CenInstance_Config", "type": "CONCEPT::Layer::AttachmentSummary"}], + "containers": [ + {"id": "Vpc", "type": "ALIYUN::ECS::VPC"}, + {"id": "CenInstance", "type": "ALIYUN::CEN::CenInstance"}, + ], + "containment": [{"resource": "layer_CenInstance_Config", "container": "CenInstance"}], + "visible_edges": [], + "explicit_relations": [], + "network_attachments": [ + { + "id": "ExternalVbrAttachment", + "type": "ALIYUN::CEN::CenInstanceAttachment", + "network": "CEN", + "child_instance_type": "VBR", + "child_instance_id": "Ref:OtherVBRId", + }, + { + "id": "CurrentVpcAttachment", + "type": "ALIYUN::CEN::CenInstanceAttachment", + "network": "CEN", + "child_instance_type": "VPC", + "child_resource": "Vpc", + }, + ], + }, + { + "node_labels": [], + "edges": [], + "views": [ + { + "id": "overview", + "layout": "contained", + "nodes": ["Vpc"], + "edges": [], + }, + { + "id": "detail_network", + "title": "CEN 互联详情", + "layout": "flat", + "anchors": ["Vpc"], + "nodes": ["Vpc", "layer_CenInstance_Config"], + "edges": [ + { + "from": "Vpc", + "to": "layer_CenInstance_Config", + "kind": "dependency", + "label": "连接外部VPC/VBR", + }, + ], + }, + ], + }, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": [], + "rejected_edges": [], + } + }, + ) + + assert not any("crosses VPCs and should mention CEN or cross-VPC" in issue for issue in issues) + + +def test_validate_semantic_plan_result_allows_group_anchor_when_parent_container_is_selected(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "BackendServer1", "type": "ALIYUN::ECS::Instance"}, + {"id": "BackendServer2", "type": "ALIYUN::ECS::Instance"}, + {"id": "layer_CenInstance_Config", "type": "CONCEPT::Layer::AttachmentSummary"}, + ], + "containers": [{"id": "Vpc", "type": "ALIYUN::ECS::VPC"}], + "containment": [ + {"resource": "BackendServer1", "container": "Vpc"}, + {"resource": "BackendServer2", "container": "Vpc"}, + ], + "visible_edges": [], + "explicit_relations": [], + "network_attachments": [ + { + "id": "TheCenVpcAttachment", + "type": "ALIYUN::CEN::CenInstanceAttachment", + "network": "CEN", + "child_instance_type": "VPC", + "child_resource": "Vpc", + } + ], + }, + { + "node_labels": [], + "edges": [], + "views": [ + { + "id": "overview", + "layout": "contained", + "groups": [ + { + "id": "BackendGroup", + "label": "后端服务器组", + "members": ["BackendServer1", "BackendServer2"], + "parent": "Vpc", + } + ], + "nodes": ["BackendGroup"], + "edges": [], + }, + { + "id": "detail_network", + "layout": "flat", + "anchors": ["BackendGroup"], + "nodes": ["Vpc", "layer_CenInstance_Config"], + "edges": [ + {"from": "Vpc", "to": "layer_CenInstance_Config", "kind": "dependency", "label": "CEN 接入"} + ], + }, + ], + }, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": [], + "rejected_edges": [], + } + }, + ) + + assert not any( + "view detail_network should include anchored network domains BackendGroup" in issue for issue in issues + ) + + +def test_validate_semantic_plan_result_allows_overview_container_boundary_for_connected_group(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "LoadBalancer", "type": "ALIYUN::SLB::LoadBalancer"}, + {"id": "BackendServer1", "type": "ALIYUN::ECS::Instance"}, + {"id": "BackendServer2", "type": "ALIYUN::ECS::Instance"}, + ], + "containers": [{"id": "Vpc", "type": "ALIYUN::ECS::VPC"}], + "containment": [ + {"resource": "BackendServer1", "container": "Vpc"}, + {"resource": "BackendServer2", "container": "Vpc"}, + ], + "visible_edges": [], + "explicit_relations": [], + }, + { + "node_labels": [], + "edges": [{"from": "LoadBalancer", "to": "BackendGroup", "kind": "traffic", "label": "转发请求"}], + "views": [ + { + "id": "overview", + "layout": "contained", + "groups": [ + { + "id": "BackendGroup", + "label": "后端服务器组", + "members": ["BackendServer1", "BackendServer2"], + "parent": "Vpc", + } + ], + "nodes": ["LoadBalancer", "BackendGroup", "Vpc"], + "edges": [{"from": "LoadBalancer", "to": "BackendGroup", "kind": "traffic", "label": "转发请求"}], + } + ], + }, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": [ + {"from": "LoadBalancer", "to": "BackendGroup", "kind": "traffic", "label": "转发请求"} + ], + "rejected_edges": [], + } + }, + ) + + assert not any("view overview has isolated nodes Vpc" in issue for issue in issues) + + +def test_validate_semantic_plan_result_requires_detail_view_anchors(): + module = _load_script_module() + + accepted_edges = [{"from": "Entry", "to": "App", "kind": "traffic", "label": "转发"}] + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "Entry", "type": "ALIYUN::ALB::LoadBalancer"}, + {"id": "App", "type": "ALIYUN::ECS::InstanceGroup"}, + ], + "containers": [], + "visible_edges": [], + }, + { + "node_labels": [], + "edges": accepted_edges, + "views": [ + { + "id": "overview", + "title": "总览", + "purpose": "整体架构", + "nodes": ["Entry", "App"], + "edges": accepted_edges, + }, + { + "id": "detail_app", + "title": "应用展开", + "purpose": "展开应用", + "nodes": ["Entry", "App"], + "edges": accepted_edges, + }, + ], + }, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": accepted_edges, + "rejected_edges": [], + } + }, + ) + + assert any("view detail_app must include anchors" in issue for issue in issues) + + +def test_validate_semantic_plan_result_requires_detail_anchors_to_exist_in_overview(): + module = _load_script_module() + + accepted_edges = [{"from": "Entry", "to": "App", "kind": "traffic", "label": "转发"}] + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "Entry", "type": "ALIYUN::ALB::LoadBalancer"}, + {"id": "App", "type": "ALIYUN::ECS::InstanceGroup"}, + {"id": "Db", "type": "ALIYUN::RDS::DBInstance"}, + ], + "containers": [], + "visible_edges": [], + }, + { + "node_labels": [], + "edges": accepted_edges, + "views": [ + { + "id": "overview", + "title": "总览", + "purpose": "整体架构", + "nodes": ["Entry", "App"], + "edges": accepted_edges, + }, + { + "id": "detail_app", + "title": "应用展开", + "purpose": "展开应用", + "anchors": ["Db"], + "nodes": ["App", "Db"], + "edges": [{"from": "App", "to": "Db", "kind": "traffic", "label": "访问"}], + }, + ], + }, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": accepted_edges, + "rejected_edges": [], + } + }, + ) + + assert any("view detail_app anchor Db is not present in overview" in issue for issue in issues) + + +def test_validate_semantic_plan_result_allows_overview_summary_group_anchor(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "Alb1", "type": "ALIYUN::ALB::LoadBalancer"}, + {"id": "Alb2", "type": "ALIYUN::ALB::LoadBalancer"}, + {"id": "App", "type": "ALIYUN::ECS::InstanceGroup"}, + ], + "containers": [], + "visible_edges": [], + }, + { + "node_labels": [], + "edges": [], + "views": [ + { + "id": "overview", + "title": "总览", + "purpose": "整体架构", + "groups": [{"id": "AlbGroup", "label": "生产 ALB", "members": ["Alb1", "Alb2"]}], + "nodes": ["AlbGroup", "App"], + "edges": [{"from": "AlbGroup", "to": "App", "kind": "traffic", "label": "分发流量"}], + }, + { + "id": "detail_app", + "title": "应用展开", + "purpose": "展开应用", + "anchors": ["AlbGroup"], + "nodes": ["Alb1", "Alb2", "App"], + "edges": [ + {"from": "Alb1", "to": "App", "kind": "traffic", "label": "分发流量"}, + {"from": "Alb2", "to": "App", "kind": "traffic", "label": "分发流量"}, + ], + }, + ], + }, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": [], + "rejected_edges": [], + } + }, + ) + + assert not any("AlbGroup" in issue for issue in issues) + + +def test_validate_semantic_plan_result_rejects_unknown_summary_group_members(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [{"id": "Alb1", "type": "ALIYUN::ALB::LoadBalancer"}], + "containers": [], + "visible_edges": [], + }, + { + "node_labels": [], + "edges": [], + "views": [ + { + "id": "overview", + "title": "总览", + "purpose": "整体架构", + "groups": [{"id": "AlbGroup", "label": "生产 ALB", "members": ["Alb1", "MissingAlb"]}], + "nodes": ["AlbGroup"], + "edges": [], + } + ], + }, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": [], + "rejected_edges": [], + } + }, + ) + + assert any("view overview group AlbGroup references unknown member MissingAlb" in issue for issue in issues) + + +def test_validate_semantic_plan_result_requires_cross_vpc_load_balancer_edge_label(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "Nlb", "type": "ALIYUN::NLB::LoadBalancer"}, + {"id": "Alb", "type": "ALIYUN::ALB::LoadBalancer"}, + ], + "containers": [ + {"id": "DmzVpc", "type": "ALIYUN::ECS::VPC"}, + {"id": "PrdVpc", "type": "ALIYUN::ECS::VPC"}, + ], + "containment": [ + {"resource": "Nlb", "container": "DmzVpc"}, + {"resource": "Alb", "container": "PrdVpc"}, + ], + "visible_edges": [], + }, + { + "node_labels": [], + "edges": [{"from": "Nlb", "to": "Alb", "kind": "traffic", "label": "后端转发"}], + "views": [ + { + "id": "overview", + "title": "总览", + "purpose": "整体架构", + "nodes": ["Nlb", "Alb"], + "edges": [{"from": "Nlb", "to": "Alb", "kind": "traffic", "label": "后端转发"}], + } + ], + }, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": [], + "rejected_edges": [], + } + }, + ) + + assert any("crosses VPCs and should mention CEN or cross-VPC" in issue for issue in issues) + + +def test_validate_semantic_plan_result_rejects_overview_direct_vpc_edge_when_cen_is_present(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "Nlb", "type": "ALIYUN::NLB::LoadBalancer"}, + {"id": "Alb", "type": "ALIYUN::ALB::LoadBalancer"}, + {"id": "TransitRouter", "type": "ALIYUN::CEN::TransitRouter"}, + ], + "containers": [ + {"id": "DmzVpc", "type": "ALIYUN::ECS::VPC"}, + {"id": "PrdVpc", "type": "ALIYUN::ECS::VPC"}, + ], + "containment": [ + {"resource": "Nlb", "container": "DmzVpc"}, + {"resource": "Alb", "container": "PrdVpc"}, + ], + "visible_edges": [], + }, + { + "node_labels": [], + "edges": [], + "views": [ + { + "id": "overview", + "title": "总览", + "purpose": "整体架构", + "groups": [ + {"id": "DmzGroup", "label": "DMZ VPC", "members": ["Nlb"], "parent": "DmzVpc"}, + {"id": "PrdGroup", "label": "生产 VPC", "members": ["Alb"], "parent": "PrdVpc"}, + ], + "nodes": ["DmzGroup", "PrdGroup", "TransitRouter"], + "edges": [ + {"from": "DmzGroup", "to": "TransitRouter", "kind": "dependency", "label": "CEN 接入"}, + {"from": "PrdGroup", "to": "TransitRouter", "kind": "dependency", "label": "CEN 接入"}, + {"from": "DmzGroup", "to": "PrdGroup", "kind": "traffic", "label": "NLB 后端转发"}, + ], + } + ], + }, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": [], + "rejected_edges": [], + } + }, + ) + + assert any("overview edge DmzGroup->PrdGroup crosses VPCs; route it through CEN" in issue for issue in issues) + + +def test_validate_semantic_plan_result_rejects_load_balancer_to_cen_business_edge(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "Nlb", "type": "ALIYUN::NLB::LoadBalancer"}, + {"id": "TransitRouter", "type": "ALIYUN::CEN::TransitRouter"}, + ], + "containers": [], + "containment": [], + "visible_edges": [], + }, + { + "node_labels": [], + "edges": [], + "views": [ + { + "id": "overview", + "title": "总览", + "purpose": "整体架构", + "nodes": ["Nlb", "TransitRouter"], + "edges": [{"from": "Nlb", "to": "TransitRouter", "kind": "traffic", "label": "入口流量"}], + } + ], + }, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": [], + "rejected_edges": [], + } + }, + ) + + assert any("uses CEN/TransitRouter as a business traffic endpoint" in issue for issue in issues) + + +def test_validate_semantic_plan_result_rejects_nat_to_load_balancer_public_access_edge(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "NatGateway", "type": "ALIYUN::VPC::NatGateway"}, + {"id": "Nlb", "type": "ALIYUN::NLB::LoadBalancer"}, + ], + "containers": [], + "containment": [], + "visible_edges": [], + }, + { + "node_labels": [], + "edges": [], + "views": [ + { + "id": "overview", + "title": "总览", + "purpose": "整体架构", + "nodes": ["NatGateway", "Nlb"], + "edges": [{"from": "NatGateway", "to": "Nlb", "kind": "management", "label": "公网访问"}], + } + ], + }, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": [], + "rejected_edges": [], + } + }, + ) + + assert any("NAT/SNAT should not be drawn as load balancer ingress" in issue for issue in issues) + + +def test_validate_semantic_plan_result_rejects_cen_vpc_connection_to_load_balancer_in_network_detail(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "TransitRouter", "type": "ALIYUN::CEN::TransitRouter"}, + {"id": "Alb", "type": "ALIYUN::ALB::LoadBalancer"}, + ], + "containers": [ + {"id": "PrdVpc", "type": "ALIYUN::ECS::VPC"}, + ], + "containment": [ + {"resource": "Alb", "container": "PrdVpc"}, + ], + "visible_edges": [], + }, + { + "node_labels": [], + "edges": [], + "views": [ + { + "id": "overview", + "title": "总览", + "purpose": "整体架构", + "nodes": ["TransitRouter", "Alb"], + "edges": [{"from": "TransitRouter", "to": "Alb", "kind": "dependency", "label": "生产 VPC 连接"}], + }, + { + "id": "detail_network", + "title": "网络详情", + "purpose": "展开 CEN", + "anchors": ["TransitRouter", "Alb"], + "nodes": ["TransitRouter", "Alb"], + "edges": [{"from": "TransitRouter", "to": "Alb", "kind": "dependency", "label": "生产 VPC 连接"}], + }, + ], + }, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": [], + "rejected_edges": [], + } + }, + ) + + assert any("connects CEN/TransitRouter to a load balancer" in issue for issue in issues) + + +def test_validate_semantic_plan_result_requires_network_detail_to_show_anchored_domains(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "TransitRouter", "type": "ALIYUN::CEN::TransitRouter"}, + {"id": "RouteConfig", "type": "CONCEPT::Layer::AttachmentSummary"}, + {"id": "Nat", "type": "ALIYUN::VPC::NatGateway"}, + {"id": "Nlb", "type": "ALIYUN::NLB::LoadBalancer"}, + {"id": "Alb", "type": "ALIYUN::ALB::LoadBalancer"}, + ], + "containers": [ + {"id": "DmzVpc", "type": "ALIYUN::ECS::VPC"}, + {"id": "PrdVpc", "type": "ALIYUN::ECS::VPC"}, + ], + "containment": [ + {"resource": "Nlb", "container": "DmzVpc"}, + {"resource": "Nat", "container": "DmzVpc"}, + {"resource": "Alb", "container": "PrdVpc"}, + ], + "visible_edges": [], + }, + { + "node_labels": [], + "edges": [], + "views": [ + { + "id": "overview", + "title": "总览", + "purpose": "整体架构", + "groups": [ + {"id": "DmzGroup", "label": "DMZ VPC", "members": ["Nlb", "Nat"], "parent": "DmzVpc"}, + {"id": "PrdGroup", "label": "生产 VPC", "members": ["Alb"], "parent": "PrdVpc"}, + ], + "nodes": ["DmzGroup", "PrdGroup", "TransitRouter"], + "edges": [ + {"from": "DmzGroup", "to": "TransitRouter", "kind": "dependency", "label": "CEN 接入"}, + {"from": "PrdGroup", "to": "TransitRouter", "kind": "dependency", "label": "CEN 接入"}, + ], + }, + { + "id": "detail_network", + "title": "网络详情", + "purpose": "展开网络", + "anchors": ["DmzGroup", "PrdGroup", "TransitRouter"], + "nodes": ["RouteConfig", "TransitRouter", "Nat"], + "edges": [ + {"from": "RouteConfig", "to": "TransitRouter", "kind": "dependency", "label": "CEN 接入"}, + {"from": "Nat", "to": "RouteConfig", "kind": "management", "label": "SNAT 路由"}, + ], + }, + ], + }, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": [], + "rejected_edges": [], + } + }, + ) + + assert any("view detail_network should include anchored network domains" in issue for issue in issues) + + +def test_validate_semantic_plan_result_requires_multi_vswitch_detail_to_show_network_domains(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "BareMetalGroup", "type": "ALIYUN::ECS::InstanceGroup"}, + {"id": "VCenter", "type": "ALIYUN::ECS::Instance"}, + {"id": "Nat", "type": "ALIYUN::VPC::NatGateway"}, + ], + "containers": [ + {"id": "Vpc", "type": "ALIYUN::ECS::VPC"}, + {"id": "ManagementVSwitch", "type": "ALIYUN::ECS::VSwitch", "parent": "Vpc"}, + {"id": "OverlayVSwitch", "type": "ALIYUN::ECS::VSwitch", "parent": "Vpc"}, + {"id": "ExternalVSwitch", "type": "ALIYUN::ECS::VSwitch", "parent": "Vpc"}, + ], + "containment": [ + {"resource": "BareMetalGroup", "container": "ExternalVSwitch"}, + {"resource": "VCenter", "container": "ManagementVSwitch"}, + {"resource": "Nat", "container": "ExternalVSwitch"}, + ], + "visible_edges": [], + }, + { + "node_labels": [], + "edges": [ + {"from": "VCenter", "to": "BareMetalGroup", "kind": "management", "label": "VMware 管理"}, + {"from": "Nat", "to": "BareMetalGroup", "kind": "traffic", "label": "SNAT 出网"}, + ], + "views": [ + { + "id": "overview", + "title": "VMware 上云架构概览", + "layout": "contained", + "nodes": ["BareMetalGroup", "VCenter", "Nat"], + "edges": [ + {"from": "VCenter", "to": "BareMetalGroup", "kind": "management", "label": "VMware 管理"}, + {"from": "Nat", "to": "BareMetalGroup", "kind": "traffic", "label": "SNAT 出网"}, + ], + }, + { + "id": "detail_network", + "title": "多交换机网络分区详情", + "purpose": "展开裸金属实例的多网卡与不同业务子网的连接关系", + "anchors": ["BareMetalGroup"], + "nodes": ["BareMetalGroup"], + "edges": [], + }, + ], + }, + {"semantic_plan": {"accepted_node_labels": [], "rejected_node_labels": [], "accepted_edges": []}}, + ) + + assert any("view detail_network should include VSwitch/network domains" in issue for issue in issues) + + +def test_validate_semantic_plan_result_allows_multi_vswitch_detail_with_route_domain_concepts(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "DmzRouteDomain", "type": "CONCEPT::Layer::AttachmentSummary"}, + {"id": "ProdRouteDomain", "type": "CONCEPT::Layer::AttachmentSummary"}, + {"id": "TransitRouter", "type": "ALIYUN::CEN::TransitRouter"}, + ], + "containers": [ + {"id": "Vpc", "type": "ALIYUN::ECS::VPC"}, + {"id": "VSwitch1", "type": "ALIYUN::ECS::VSwitch", "parent": "Vpc"}, + {"id": "VSwitch2", "type": "ALIYUN::ECS::VSwitch", "parent": "Vpc"}, + {"id": "VSwitch3", "type": "ALIYUN::ECS::VSwitch", "parent": "Vpc"}, + ], + "containment": [], + "visible_edges": [], + }, + { + "node_labels": [], + "edges": [ + {"from": "DmzRouteDomain", "to": "TransitRouter", "kind": "management", "label": "CEN 接入"}, + {"from": "ProdRouteDomain", "to": "TransitRouter", "kind": "management", "label": "CEN 接入"}, + ], + "views": [ + { + "id": "overview", + "title": "概览", + "layout": "contained", + "nodes": ["DmzRouteDomain", "ProdRouteDomain", "TransitRouter"], + "edges": [ + {"from": "DmzRouteDomain", "to": "TransitRouter", "kind": "management", "label": "CEN 接入"}, + { + "from": "ProdRouteDomain", + "to": "TransitRouter", + "kind": "management", + "label": "CEN 接入", + }, + ], + }, + { + "id": "detail_network", + "title": "CEN 路由详情", + "purpose": "展开 DMZ 和生产路由域", + "anchors": ["DmzRouteDomain", "ProdRouteDomain"], + "nodes": ["DmzRouteDomain", "ProdRouteDomain", "TransitRouter"], + "edges": [ + {"from": "DmzRouteDomain", "to": "TransitRouter", "kind": "management", "label": "CEN 接入"}, + { + "from": "ProdRouteDomain", + "to": "TransitRouter", + "kind": "management", + "label": "CEN 接入", + }, + ], + }, + ], + }, + {"semantic_plan": {"accepted_node_labels": [], "rejected_node_labels": [], "accepted_edges": []}}, + ) + + assert not any("view detail_network should include VSwitch/network domains" in issue for issue in issues) + + +def test_validate_semantic_plan_result_allows_detail_network_anchor_to_business_summary_group(): + module = _load_script_module() + + issues = module.validate_semantic_plan_result( + { + "target_language": {"code": "zh"}, + "visible_nodes": [ + {"id": "Nlb", "type": "ALIYUN::NLB::LoadBalancer"}, + {"id": "Alb1", "type": "ALIYUN::ALB::LoadBalancer"}, + {"id": "Alb2", "type": "ALIYUN::ALB::LoadBalancer"}, + {"id": "TransitRouter", "type": "ALIYUN::CEN::TransitRouter"}, + {"id": "RouteConfig", "type": "CONCEPT::Layer::AttachmentSummary"}, + ], + "containers": [], + "containment": [], + "visible_edges": [], + }, + { + "node_labels": [], + "edges": [], + "views": [ + { + "id": "overview", + "title": "总览", + "purpose": "整体架构", + "layout": "contained", + "groups": [{"id": "ProdAlbGroup", "label": "生产 ALB 集群", "members": ["Alb1", "Alb2"]}], + "nodes": ["Nlb", "ProdAlbGroup"], + "edges": [{"from": "Nlb", "to": "ProdAlbGroup", "kind": "traffic", "label": "经 CEN 转发"}], + }, + { + "id": "detail_network", + "title": "网络详情", + "purpose": "展开网络", + "anchors": ["Nlb", "ProdAlbGroup"], + "nodes": ["TransitRouter", "RouteConfig"], + "edges": [ + {"from": "RouteConfig", "to": "TransitRouter", "kind": "dependency", "label": "CEN 接入"}, + ], + }, + ], + }, + { + "semantic_plan": { + "accepted_node_labels": [], + "rejected_node_labels": [], + "accepted_edges": [], + "rejected_edges": [], + } + }, + ) + + assert not any( + "view detail_network should include anchored network domains ProdAlbGroup" in issue for issue in issues + ) + + +def test_browser_mermaid_source_quotes_subgraph_labels_for_mermaid_v11(): + module = _load_script_module() + + result = module.browser_mermaid_source( + """graph TD + subgraph layer_VPC [VPC (192.168.0.0/16)] + ECS["ECS"] + end +""" + ) + + assert 'subgraph layer_VPC["VPC (192.168.0.0/16)"]' in result + + +def test_parse_args_accepts_terminal_asset_outputs(tmp_path): + module = _load_script_module() + + args = module.parse_args( + [ + "template.yml", + "--terminal-svg-out", + str(tmp_path / "diagram.svg"), + "--terminal-png-out", + str(tmp_path / "diagram.png"), + ] + ) + + assert args.terminal_svg_out == tmp_path / "diagram.svg" + assert args.terminal_png_out == tmp_path / "diagram.png" + + +def test_parse_args_accepts_terminal_recording_outputs(tmp_path): + module = _load_script_module() + + args = module.parse_args( + [ + "template.yml", + "--record-terminal-png-out", + str(tmp_path / "diagram.png"), + "--record-terminal-gif-out", + str(tmp_path / "diagram.gif"), + "--record-terminal-cast-out", + str(tmp_path / "diagram.cast"), + "--record-terminal-cols", + "220", + "--record-terminal-rows", + "140", + ] + ) + + assert args.record_terminal_png_out == tmp_path / "diagram.png" + assert args.record_terminal_gif_out == tmp_path / "diagram.gif" + assert args.record_terminal_cast_out == tmp_path / "diagram.cast" + assert args.record_terminal_cols == 220 + assert args.record_terminal_rows == 140 + + +def test_parse_args_accepts_multi_view_output_dirs(tmp_path): + module = _load_script_module() + + args = module.parse_args( + [ + "template.yml", + "--view-mermaid-dir", + str(tmp_path / "mmd"), + "--terminal-svg-dir", + str(tmp_path / "svg"), + "--terminal-png-dir", + str(tmp_path / "png"), + ] + ) + + assert args.view_mermaid_dir == tmp_path / "mmd" + assert args.terminal_svg_dir == tmp_path / "svg" + assert args.terminal_png_dir == tmp_path / "png" + + +def test_parse_args_accepts_quiet_terminal_preview_mode(): + module = _load_script_module() + + args = module.parse_args(["template.yml", "--quiet"]) + + assert args.quiet is True + + +def test_parse_args_disables_thinking_by_default_but_allows_opt_in(): + module = _load_script_module() + + default_args = module.parse_args(["template.yml"]) + thinking_args = module.parse_args(["template.yml", "--enable-thinking"]) + + assert default_args.enable_thinking is False + assert thinking_args.enable_thinking is True + + +def test_format_timing_summary_reports_key_stages(): + module = _load_script_module() + + summary = module.format_timing_summary( + { + "load_and_facts": 0.05, + "llm": 123.45, + "validate": 0.1, + "write_outputs": 0.2, + "terminal_preview": 1.2, + "total": 125.0, + } + ) + + assert summary == ( + "timing: load/facts=50ms, llm=123.5s, validate/render=100ms, " + "write outputs=200ms, terminal preview=1.2s, total=125.0s" + ) + + +def test_svg_to_png_command_prefers_available_converter(monkeypatch, tmp_path): + module = _load_script_module() + svg_path = tmp_path / "diagram.svg" + png_path = tmp_path / "diagram.png" + + monkeypatch.setattr( + module.shutil, + "which", + lambda command: "/usr/bin/rsvg-convert" if command == "rsvg-convert" else None, + ) + + assert module._svg_to_png_command(svg_path, png_path) == ["rsvg-convert", str(svg_path), "-o", str(png_path)] + + +def test_write_terminal_svg_records_without_stdout(monkeypatch, tmp_path, capsys): + module = _load_script_module() + + calls = [] + monkeypatch.setattr(module, "_render_terminal_rich", lambda source: calls.append(source) or "diagram") + svg_path = tmp_path / "diagram.svg" + + module.write_terminal_svg(svg_path, "graph TD\n A-->B", width=80, title="diagram") + + assert svg_path.exists() + assert calls == ["graph TD\n A-->B"] + assert "diagram" not in capsys.readouterr().out + + +def test_convert_svg_to_png_suppresses_converter_output(monkeypatch, tmp_path): + module = _load_script_module() + svg_path = tmp_path / "diagram.svg" + png_path = tmp_path / "diagram.png" + calls = [] + + monkeypatch.setattr(module, "_svg_to_png_command", lambda _svg, _png: ["converter", str(svg_path), str(png_path)]) + monkeypatch.setattr(module.subprocess, "run", lambda *args, **kwargs: calls.append((args, kwargs))) + + module.convert_svg_to_png(svg_path, png_path) + + assert calls + assert calls[0][1]["stdout"] is module.subprocess.PIPE + assert calls[0][1]["stderr"] is module.subprocess.PIPE + + +def test_svg_to_png_command_supports_macos_sips(monkeypatch, tmp_path): + module = _load_script_module() + svg_path = tmp_path / "diagram.svg" + png_path = tmp_path / "diagram.png" + + monkeypatch.setattr(module.shutil, "which", lambda command: "/usr/bin/sips" if command == "sips" else None) + + assert module._svg_to_png_command(svg_path, png_path) == [ + "sips", + "-s", + "format", + "png", + str(svg_path), + "--out", + str(png_path), + ] + + +def test_record_terminal_preview_requires_asciinema(monkeypatch, tmp_path): + module = _load_script_module() + args = module.parse_args( + [ + "template.yml", + "--record-terminal-png-out", + str(tmp_path / "diagram.png"), + ] + ) + + monkeypatch.setattr(module.shutil, "which", lambda _command: None) + + with pytest.raises(RuntimeError, match="asciinema"): + module.record_terminal_preview(args) + + +def test_record_terminal_preview_runs_asciinema_agg_and_ffmpeg(monkeypatch, tmp_path): + module = _load_script_module() + png_path = tmp_path / "diagram.png" + gif_path = tmp_path / "diagram.gif" + cast_path = tmp_path / "diagram.cast" + args = module.parse_args( + [ + "template.yml", + "--model", + "qwen-test", + "--max-attempts", + "2", + "--record-terminal-png-out", + str(png_path), + "--record-terminal-gif-out", + str(gif_path), + "--record-terminal-cast-out", + str(cast_path), + "--record-terminal-cols", + "200", + "--record-terminal-rows", + "120", + ] + ) + calls: list[list[str]] = [] + + monkeypatch.setattr( + module.shutil, + "which", + lambda command: f"/usr/bin/{command}" if command in {"asciinema", "agg", "ffmpeg"} else None, + ) + monkeypatch.setattr(module.subprocess, "run", lambda command, **_kwargs: calls.append(command)) + + module.record_terminal_preview(args) + + assert calls[0][:7] == [ + "asciinema", + "rec", + "-q", + "--overwrite", + "--headless", + "--return", + "--window-size", + ] + assert calls[0][7] == "200x120" + assert calls[0][-1] == str(cast_path) + child_command = calls[0][calls[0].index("-c") + 1] + assert "preview_template_architecture_llm.py" in child_command + assert "--quiet" in child_command + assert "--width 200" in child_command + assert "--model qwen-test" in child_command + assert calls[1] == [ + "agg", + "-q", + "--cols", + "200", + "--rows", + "120", + "--font-size", + "16", + "--line-height", + "1.25", + "--theme", + "github-dark", + "--select", + "100%", + str(cast_path), + str(gif_path), + ] + assert calls[2] == [ + "ffmpeg", + "-y", + "-loglevel", + "error", + "-i", + str(gif_path), + "-frames:v", + "1", + str(png_path), + ] + + +def test_record_terminal_child_command_preserves_semantic_output_paths(tmp_path): + module = _load_script_module() + args = module.parse_args( + [ + "template.yml", + "--mermaid-out", + str(tmp_path / "diagram.mmd"), + "--plan-out", + str(tmp_path / "plan.json"), + "--view-mermaid-dir", + str(tmp_path / "views"), + "--prompt-debug-html-out", + str(tmp_path / "prompts.html"), + "--record-terminal-png-out", + str(tmp_path / "terminal.png"), + "--record-terminal-gif-out", + str(tmp_path / "terminal.gif"), + "--record-terminal-cast-out", + str(tmp_path / "terminal.cast"), + ] + ) + + command = module._record_terminal_child_command(args, width=220) + + assert "--mermaid-out" in command + assert str(tmp_path / "diagram.mmd") in command + assert "--plan-out" in command + assert str(tmp_path / "plan.json") in command + assert "--view-mermaid-dir" in command + assert str(tmp_path / "views") in command + assert "--prompt-debug-html-out" in command + assert str(tmp_path / "prompts.html") in command + assert "--record-terminal-png-out" not in command + assert "--record-terminal-gif-out" not in command + assert "--record-terminal-cast-out" not in command + + +def test_terminal_preview_items_use_single_semantic_view_instead_of_base_diagram(): + module = _load_script_module() + + items = module._terminal_preview_items( + "graph TD\n Base[old base diagram]", + SimpleNamespace( + views=( + SimpleNamespace( + id="overview", + title="架构概览", + mermaid_source="graph TD\n Overview[new view diagram]", + ), + ) + ), + ) + + assert [(item.id, item.title, item.mermaid_source) for item in items] == [ + ("overview", "架构概览", "graph TD\n Overview[new view diagram]") + ] diff --git a/tests/ui/components/test_candidate_selection.py b/tests/ui/components/test_candidate_selection.py index 1bee428c..f8cfbde2 100644 --- a/tests/ui/components/test_candidate_selection.py +++ b/tests/ui/components/test_candidate_selection.py @@ -3,6 +3,7 @@ from io import StringIO from rich.console import Console +from rich.text import Text from iac_code.ui.components.candidate_selection import CandidateSelectionRenderer from iac_code.ui.core.key_event import KeyEvent @@ -249,6 +250,34 @@ def test_duplicate_candidate_names_get_distinct_display_labels(self): assert "Same #1" in output assert "Same #2" in output + def test_render_keeps_diagram_switch_hint_visible_for_tall_diagram(self, monkeypatch): + output = StringIO() + console = Console(file=output, force_terminal=True, no_color=True, width=100, height=18) + r = CandidateSelectionRenderer(console=console) + r.enter_selection_mode() + r.set_status_message("架构图优化中...") + r.add_diagram( + "方案1", + "graph TD\nA-->B", + views=[ + {"id": "overview", "title": "架构概览", "mermaid_source": "graph TD\nA-->B"}, + {"id": "detail", "title": "网络详情", "mermaid_source": "graph TD\nB-->C"}, + ], + ) + r.add_detail( + "tu_1", "方案1", "方案说明", [{"name": "VSwitch", "spec": "交换机", "monthly_cost": "¥0/月"}], "¥0/月" + ) + monkeypatch.setattr( + r, "_render_diagram", lambda _source: Text("\n".join(f"diagram line {i}" for i in range(60))) + ) + + console.print(r.render()) + lines = output.getvalue().splitlines() + + assert len(lines) <= console.height + assert "Tab/[ ]" in lines[-1] + assert "switch diagrams" in lines[-1] or "切换架构图" in lines[-1] + class TestCandidateSelectionRendererSelection: def test_enter_selection_mode(self): diff --git a/tests/ui/test_candidate_selection_streaming.py b/tests/ui/test_candidate_selection_streaming.py index d1deb18e..7e0c69c2 100644 --- a/tests/ui/test_candidate_selection_streaming.py +++ b/tests/ui/test_candidate_selection_streaming.py @@ -2,6 +2,8 @@ from __future__ import annotations +from io import StringIO + from iac_code.utils.json_utils import extract_json_string_value @@ -72,6 +74,14 @@ def test_multiple_spaces_after_colon(self): class TestCandidateSelectionRendererStreaming: + @staticmethod + def _render_to_text(renderable) -> str: + from rich.console import Console + + output = StringIO() + Console(file=output, force_terminal=True, no_color=True, width=120).print(renderable) + return output.getvalue() + def test_update_streaming_summary_creates_tab(self): from rich.console import Console @@ -120,3 +130,86 @@ def test_diagram_tab_gets_streaming_summary(self): tab = renderer._tabs[0] assert tab.mermaid_source == "graph TD; A-->B" assert tab.summary == "streaming text" + + def test_draft_diagram_keeps_optimization_status_until_optimized_views_arrive(self): + from rich.console import Console + + from iac_code.ui.components.candidate_selection import CandidateSelectionRenderer + + renderer = CandidateSelectionRenderer(console=Console(force_terminal=True, width=120)) + renderer.add_diagram( + "方案A", + "graph TD; Draft-->B", + diagram_stage="draft", + views=[ + { + "id": "overview", + "title": "架构概览", + "mermaid_source": "graph TD; Draft-->B", + } + ], + ) + + rendered = self._render_to_text(renderer.render()) + + assert "架构图优化中" in rendered + tab = renderer._tabs[0] + assert tab.mermaid_source == "graph TD; Draft-->B" + assert tab.diagram_stage == "draft" + assert [view.title for view in tab.diagram_views] == ["架构概览"] + + renderer.add_diagram( + "方案A", + "graph TD; Optimized-->B", + diagram_stage="optimized", + views=[ + { + "id": "overview", + "title": "架构概览", + "mermaid_source": "graph TD; Optimized-->B", + }, + { + "id": "detail_app", + "title": "应用详情", + "mermaid_source": "graph TD; App-->B", + }, + ], + ) + + rendered_after_update = self._render_to_text(renderer.render()) + + assert "架构图优化中" not in rendered_after_update + assert "架构概览" in rendered_after_update + assert "应用详情" in rendered_after_update + assert renderer._tabs[0].diagram_stage == "optimized" + + def test_bracket_keys_switch_diagram_views_inside_selected_candidate(self): + from rich.console import Console + + from iac_code.ui.components.candidate_selection import CandidateSelectionRenderer + from iac_code.ui.core.key_event import KeyEvent + + renderer = CandidateSelectionRenderer(console=Console(force_terminal=True, width=120)) + renderer.add_diagram( + "方案A", + "graph TD; Overview-->B", + views=[ + { + "id": "overview", + "title": "架构概览", + "mermaid_source": "graph TD; Overview-->B", + }, + { + "id": "detail_app", + "title": "应用详情", + "mermaid_source": "graph TD; App-->B", + }, + ], + ) + + assert renderer._tabs[0].selected_diagram_view_index == 0 + assert renderer.handle_key(KeyEvent(key="]", char="]")) is True + assert renderer._tabs[0].selected_diagram_view_index == 1 + assert "App" in self._render_to_text(renderer.render()) + assert renderer.handle_key(KeyEvent(key="[", char="[")) is True + assert renderer._tabs[0].selected_diagram_view_index == 0 diff --git a/tests/ui/test_diagram_rendering.py b/tests/ui/test_diagram_rendering.py new file mode 100644 index 00000000..5ec2ae29 --- /dev/null +++ b/tests/ui/test_diagram_rendering.py @@ -0,0 +1,64 @@ +from rich.text import Text + +from iac_code.ui.diagram_rendering import style_attachment_lines + + +def test_style_attachment_lines_dims_node_attachment_lines(): + diagram = Text( + "┌────────────────────┐\n" + "│ ECS │\n" + "│ + EIP │\n" + "│ + Security group │\n" + "└────────────────────┘" + ) + + styled = style_attachment_lines(diagram) + + assert styled is not diagram + assert _styled_slice(styled, "+ EIP") == "dim cyan" + assert _styled_slice(styled, "+ Security group") == "dim cyan" + assert _styled_slice(styled, "ECS") is None + + +def test_style_attachment_lines_returns_non_text_renderables_unchanged(): + renderable = object() + + assert style_attachment_lines(renderable) is renderable + + +def test_style_attachment_lines_ignores_plus_text_outside_node_boxes(): + diagram = Text("+ edge label\n│ + EIP │") + + styled = style_attachment_lines(diagram) + + assert _styled_slice(styled, "+ EIP") == "dim cyan" + assert _styled_slice(styled, "+ edge label") is None + + +def test_style_attachment_lines_does_not_bleed_across_neighbor_boxes(): + diagram = Text("│ + EIP │ │ DmzCen CEN │") + + styled = style_attachment_lines(diagram) + + assert _styled_slice(styled, "+ EIP") == "dim cyan" + assert _styled_slice(styled, "DmzCen CEN") is None + + +def test_style_attachment_lines_styles_wrapped_attachment_continuation(): + diagram = Text("│ DMZ NLB │\n│ + Shared bandwidth │\n│ package │\n│ + Listener │") + + styled = style_attachment_lines(diagram) + + assert _styled_slice(styled, "+ Shared bandwidth") == "dim cyan" + assert _styled_slice(styled, "package") == "dim cyan" + assert _styled_slice(styled, "+ Listener") == "dim cyan" + assert _styled_slice(styled, "DMZ NLB") is None + + +def _styled_slice(text: Text, value: str) -> str | None: + start = text.plain.index(value) + end = start + len(value) + for span in text.spans: + if span.start <= start and span.end >= end: + return str(span.style) + return None diff --git a/tests/ui/test_renderer_events.py b/tests/ui/test_renderer_events.py index 916faee9..e789d9f5 100644 --- a/tests/ui/test_renderer_events.py +++ b/tests/ui/test_renderer_events.py @@ -6,6 +6,11 @@ from iac_code.services.telemetry.names import Events from iac_code.tools.base import ToolRegistry from iac_code.types.stream_events import ( + TOOL_RENDER_DISPLAY_NAME_KEY, + TOOL_RENDER_METADATA_KEY, + TOOL_RENDER_RESULT_COMPACT_KEY, + TOOL_RENDER_RESULT_VERBOSE_KEY, + TOOL_RENDER_VERBOSE_RESULT_IN_TRANSCRIPT_KEY, MessageEndEvent, MessageStartEvent, PermissionRequestEvent, @@ -366,28 +371,29 @@ async def _idle_key_listener(*_args, **_kwargs): class TestRendererToolResultFallback: @pytest.mark.asyncio - async def test_uses_renderer_tool_when_tool_registry_missing(self, monkeypatch): + async def test_uses_render_metadata_when_tool_registry_missing(self, monkeypatch): monkeypatch.setattr(Renderer, "_key_listener", _idle_key_listener) renderer = _make_renderer_for_tool_result_fallback_test() - renderer_tool = MagicMock() - renderer_tool.user_facing_name.return_value = "InfraGuard scan" - renderer_tool.render_tool_use_message.return_value = None - renderer_tool.render_tool_result_message.side_effect = lambda output, *, is_error=False, verbose=False: ( - "Command: infraguard scan\nStatus: passed" if verbose else "passed · 0 findings" - ) await renderer.run_streaming_output( _tool_result_events( ToolUseStartEvent( tool_use_id="tool-a", name="infraguard_scan", - renderer_tool=renderer_tool, + metadata={TOOL_RENDER_METADATA_KEY: {TOOL_RENDER_DISPLAY_NAME_KEY: "InfraGuard scan"}}, ), ToolUseEndEvent(tool_use_id="tool-a", name="infraguard_scan", input={}), ToolResultEvent( tool_use_id="tool-a", tool_name="infraguard_scan", result='{"command": ["infraguard", "scan"]}', + metadata={ + TOOL_RENDER_METADATA_KEY: { + TOOL_RENDER_RESULT_COMPACT_KEY: "passed · 0 findings", + TOOL_RENDER_RESULT_VERBOSE_KEY: "Command: infraguard scan\nStatus: passed", + TOOL_RENDER_VERBOSE_RESULT_IN_TRANSCRIPT_KEY: True, + } + }, ), ), _allow_permission, @@ -397,6 +403,41 @@ async def test_uses_renderer_tool_when_tool_registry_missing(self, monkeypatch): assert "passed · 0 findings" in output assert '{"command"' not in output + @pytest.mark.asyncio + async def test_archives_render_metadata_without_runtime_renderer_object(self, monkeypatch): + monkeypatch.setattr(Renderer, "_key_listener", _idle_key_listener) + renderer = _make_renderer_for_tool_result_fallback_test() + + await renderer.run_streaming_output( + _tool_result_events( + ToolUseStartEvent( + tool_use_id="tool-a", + name="runtime_tool", + metadata={TOOL_RENDER_METADATA_KEY: {TOOL_RENDER_DISPLAY_NAME_KEY: "Runtime tool"}}, + ), + ToolUseEndEvent(tool_use_id="tool-a", name="runtime_tool", input={}), + ToolResultEvent( + tool_use_id="tool-a", + tool_name="runtime_tool", + result="{}", + metadata={TOOL_RENDER_METADATA_KEY: {TOOL_RENDER_RESULT_COMPACT_KEY: "runtime summary"}}, + ), + ), + _allow_permission, + ) + + output = renderer.console.file.getvalue() + assert "runtime summary" in output + archived_tool = renderer.message_history[-1].segments[0].tool + assert archived_tool is not None + assert not hasattr(archived_tool, "renderer_tool") + assert archived_tool.metadata == { + TOOL_RENDER_METADATA_KEY: { + TOOL_RENDER_DISPLAY_NAME_KEY: "Runtime tool", + TOOL_RENDER_RESULT_COMPACT_KEY: "runtime summary", + } + } + @pytest.mark.asyncio async def test_does_not_fallback_stale_tool_result_id_to_same_named_tool(self, monkeypatch): monkeypatch.setattr(Renderer, "_key_listener", _idle_key_listener) diff --git a/tests/ui/test_renderer_helpers.py b/tests/ui/test_renderer_helpers.py index 09d6a214..b44c3879 100644 --- a/tests/ui/test_renderer_helpers.py +++ b/tests/ui/test_renderer_helpers.py @@ -12,7 +12,14 @@ from iac_code.pipeline.engine.cleanup import CLEANUP_PROMPT_METADATA_TYPE from iac_code.tools.base import Tool, ToolContext, ToolRegistry, ToolResult from iac_code.tools.read_file import ReadFileTool -from iac_code.types.stream_events import PermissionRequestEvent, StackInstancesProgressEvent, StackProgressEvent +from iac_code.types.stream_events import ( + TOOL_RENDER_METADATA_KEY, + TOOL_RENDER_RESULT_COMPACT_KEY, + TOOL_RENDER_RESULT_VERBOSE_KEY, + PermissionRequestEvent, + StackInstancesProgressEvent, + StackProgressEvent, +) from iac_code.ui.core.key_event import KeyEvent from iac_code.ui.renderer import ( RenderedTurn, @@ -273,18 +280,19 @@ def test_render_tool_result_uses_tool_summary(self): assert line is not None assert "done" in str(line) - def test_render_tool_result_uses_record_renderer_tool_when_registry_missing(self): + def test_render_tool_result_uses_record_render_metadata_when_registry_missing(self): renderer = Renderer(make_console(), ToolRegistry(), status_callback=lambda: "ready") - renderer_tool = MagicMock() - renderer_tool.render_tool_result_message.side_effect = lambda output, *, is_error=False, verbose=False: ( - "Command: infraguard scan\nStatus: passed" if verbose else "passed · 0 findings" - ) rec = _ToolCallRecord( tool_name="infraguard_scan", tool_input={}, done=True, result='{"command": ["infraguard", "scan"]}', - renderer_tool=renderer_tool, + metadata={ + TOOL_RENDER_METADATA_KEY: { + TOOL_RENDER_RESULT_COMPACT_KEY: "passed · 0 findings", + TOOL_RENDER_RESULT_VERBOSE_KEY: "Command: infraguard scan\nStatus: passed", + } + }, ) compact = renderer._render_tool_result(rec) diff --git a/tests/ui/test_stream_accumulator.py b/tests/ui/test_stream_accumulator.py index 09185163..bbd25112 100644 --- a/tests/ui/test_stream_accumulator.py +++ b/tests/ui/test_stream_accumulator.py @@ -1,4 +1,4 @@ -from iac_code.types.stream_events import MCPProgressEvent, ToolResultEvent, ToolUseStartEvent +from iac_code.types.stream_events import TOOL_RENDER_METADATA_KEY, MCPProgressEvent, ToolResultEvent, ToolUseStartEvent from iac_code.ui.stream_accumulator import StreamAccumulator @@ -32,13 +32,14 @@ def test_orphan_tool_result_fallback_allows_single_pending_tool_name() -> None: assert acc.tool_records["tool-a"].result == "ok" -def test_tool_use_start_records_renderer_tool() -> None: +def test_tool_use_start_records_render_metadata() -> None: acc = StreamAccumulator() - renderer_tool = object() + metadata = {TOOL_RENDER_METADATA_KEY: {"display_name": "InfraGuard scan"}} - acc.process(ToolUseStartEvent(tool_use_id="tool-a", name="infraguard_scan", renderer_tool=renderer_tool)) + acc.process(ToolUseStartEvent(tool_use_id="tool-a", name="infraguard_scan", metadata=metadata)) - assert acc.tool_records["tool-a"].renderer_tool is renderer_tool + assert acc.tool_records["tool-a"].metadata == metadata + assert not hasattr(acc.tool_records["tool-a"], "renderer_tool") def test_mcp_progress_updates_matching_tool_record() -> None: diff --git a/tests/ui/test_transcript_view.py b/tests/ui/test_transcript_view.py index b1cbd4e6..c0c293bb 100644 --- a/tests/ui/test_transcript_view.py +++ b/tests/ui/test_transcript_view.py @@ -10,6 +10,12 @@ from iac_code.pipeline.selling.tools import InfraGuardScanTool from iac_code.tools.base import ToolRegistry from iac_code.tools.read_file import ReadFileTool +from iac_code.types.stream_events import ( + TOOL_RENDER_METADATA_KEY, + TOOL_RENDER_RESULT_COMPACT_KEY, + TOOL_RENDER_RESULT_VERBOSE_KEY, + TOOL_RENDER_VERBOSE_RESULT_IN_TRANSCRIPT_KEY, +) from iac_code.ui.core.key_event import KeyEvent from iac_code.ui.renderer import RenderedTurn, Renderer, _Segment, _ToolCallRecord from iac_code.ui.transcript_view import TranscriptView @@ -129,10 +135,7 @@ def test_render_tool_inserts_prompt_between_header_and_children(self): result_pos = output.index("RESULT") assert head_pos < prompt_pos < child_pos < result_pos - def test_render_tool_uses_verbose_result_for_pipeline_renderer_tool(self): - class TranscriptVerboseTool: - render_verbose_result_in_transcript = True - + def test_render_tool_uses_verbose_result_for_pipeline_render_metadata(self): renderer = make_renderer() renderer._render_tool_result = lambda rec: Text("VERBOSE" if renderer._verbose else "COMPACT") renderer._has_verbose_content = lambda rec: True @@ -142,7 +145,7 @@ class TranscriptVerboseTool: tool_input={}, done=True, result="raw", - renderer_tool=TranscriptVerboseTool(), + metadata={TOOL_RENDER_METADATA_KEY: {TOOL_RENDER_VERBOSE_RESULT_IN_TRANSCRIPT_KEY: True}}, ) view._render_tool(rec) @@ -151,7 +154,7 @@ class TranscriptVerboseTool: assert "VERBOSE" in output assert "COMPACT" not in output - def test_render_tool_keeps_compact_result_without_pipeline_renderer_tool(self): + def test_render_tool_keeps_compact_result_without_render_metadata_opt_in(self): renderer = make_renderer() renderer._render_tool_result = lambda rec: Text("VERBOSE" if renderer._verbose else "COMPACT") renderer._has_verbose_content = lambda rec: True @@ -164,7 +167,7 @@ def test_render_tool_keeps_compact_result_without_pipeline_renderer_tool(self): assert "COMPACT" in output assert "VERBOSE" not in output - def test_render_tool_keeps_read_file_compact_even_with_renderer_tool(self): + def test_render_tool_keeps_read_file_compact_without_render_metadata_opt_in(self): renderer = make_real_renderer() view = TranscriptView(renderer) rec = _ToolCallRecord( @@ -172,7 +175,6 @@ def test_render_tool_keeps_read_file_compact_even_with_renderer_tool(self): tool_input={"path": "config.yaml"}, done=True, result=" 1\tsecret: value\n 2\tanother: value\n", - renderer_tool=ReadFileTool(), ) view._render_tool(rec) @@ -199,7 +201,15 @@ def test_render_tool_uses_verbose_result_for_infraguard_scan(self): tool_input={"file_path": "templates/demo.yml"}, done=True, result=__import__("json").dumps(result), - renderer_tool=InfraGuardScanTool(), + metadata={ + TOOL_RENDER_METADATA_KEY: { + TOOL_RENDER_RESULT_COMPACT_KEY: "passed · 0 blocking findings", + TOOL_RENDER_RESULT_VERBOSE_KEY: InfraGuardScanTool().render_tool_result_message( + __import__("json").dumps(result), verbose=True + ), + TOOL_RENDER_VERBOSE_RESULT_IN_TRANSCRIPT_KEY: True, + } + }, ) view._render_tool(rec)