nonebot-plugin-awsmgmt 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

nonebot_plugin_awsmgmt/__init__.py

@@ -1,2 +1,189 @@
-def hello() -> str:
-    return "Hello from nonebot-plugin-awsmgmt!"
+import time
+import re
+from typing import Tuple, List, Optional, Dict, Any
+from functools import wraps
+
+from nonebot import on_command
+from nonebot.matcher import Matcher
+from nonebot.permission import SUPERUSER
+from nonebot.plugin import PluginMetadata, get_plugin_config
+from nonebot.params import CommandArg
+from nonebot.adapters import Message
+from nonebot.log import logger
+from nonebot.exception import FinishedException
+
+from .config import Config
+from .ec2_manager import EC2Manager
+from .cost_explorer_manager import CostExplorerManager
+from .lightsail_manager import LightsailManager
+
+__plugin_meta__ = PluginMetadata(
+    name="AWS Manager",
+    description="Manage AWS EC2, Lightsail, and Cost Explorer via commands.",
+    usage=(
+        "--- EC2 ---\n"
+        "/ec2_start|stop|reboot|status [target]\n"
+        "Target: tag:Key:Value | id:i-xxxx\n"
+        "--- Lightsail ---\n"
+        "/lightsail_list\n"
+        "/lightsail_start|stop <instance_name>\n"
+        "--- Cost ---\n"
+        "/aws_cost today|month|month by_service"
+    ),
+    type="application",
+    homepage="https://github.com/maxesisn/nonebot-plugin-awsmgmt",
+    config=Config,
+)
+
+def handle_non_finish_exceptions(error_message: str):
+    def decorator(func):
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            try:
+                return await func(*args, **kwargs)
+            except FinishedException:
+                raise
+            except Exception as e:
+                matcher = args[0] if args else None
+                logger.error(f"Error in {func.__name__}: {e}")
+                if matcher:
+                    await matcher.finish(error_message)
+        return wrapper
+    return decorator
+
+# --- Init --- #
+plugin_config = get_plugin_config(Config)
+ec2_manager = EC2Manager(plugin_config)
+cost_manager = CostExplorerManager(plugin_config)
+lightsail_manager = LightsailManager(plugin_config)
+
+# --- Command Matchers --- #
+# EC2
+ec2_start_matcher = on_command("ec2_start", aliases={"ec2启动"}, permission=SUPERUSER)
+ec2_stop_matcher = on_command("ec2_stop", aliases={"ec2停止"}, permission=SUPERUSER)
+ec2_reboot_matcher = on_command("ec2_reboot", aliases={"ec2重启"}, permission=SUPERUSER)
+ec2_status_matcher = on_command("ec2_status", aliases={"ec2状态"}, permission=SUPERUSER)
+# Lightsail
+lightsail_list_matcher = on_command("lightsail_list", permission=SUPERUSER)
+lightsail_start_matcher = on_command("lightsail_start", permission=SUPERUSER)
+lightsail_stop_matcher = on_command("lightsail_stop", permission=SUPERUSER)
+# Cost Explorer
+cost_matcher = on_command("aws_cost", permission=SUPERUSER)
+
+
+# --- Helper Functions --- #
+
+async def parse_ec2_target(matcher: Matcher, args: Message) -> Tuple[str, str, Optional[str]]:
+    arg_str = args.extract_plain_text().strip()
+    if not arg_str:
+        if plugin_config.aws_default_target_tag:
+            arg_str = f"tag:{plugin_config.aws_default_target_tag}"
+        else:
+            await matcher.finish(__plugin_meta__.usage)
+    match = re.match(r"^(tag|id):(.*)$", arg_str)
+    if not match:
+        await matcher.finish(f"Invalid EC2 target format. \n{__plugin_meta__.usage}")
+    target_type, value = match.groups()
+    if target_type == "tag":
+        if ":" not in value:
+            await matcher.finish(f"Invalid tag format. Expected Key:Value. \n{__plugin_meta__.usage}")
+        tag_key, tag_value = value.split(":", 1)
+        return "tag", tag_key, tag_value
+    elif target_type == "id":
+        return "id", value, None
+    return "unknown", "", None
+
+def format_ec2_status(instance: Dict[str, Any]) -> str:
+    instance_id = instance.get('InstanceId', 'N/A')
+    state = instance.get('State', {}).get('Name', 'N/A')
+    public_ip = instance.get('PublicIpAddress', 'None')
+    name_tag = next((tag['Value'] for tag in instance.get('Tags', []) if tag['Key'] == 'Name'), 'No Name Tag')
+    return f"- {instance_id} ({name_tag})\n  State: {state}\n  Public IP: {public_ip}"
+
+
+# --- EC2 Handlers --- #
+
+@ec2_status_matcher.handle()
+@handle_non_finish_exceptions("An error occurred while fetching EC2 status.")
+async def handle_ec2_status(matcher: Matcher, args: Message = CommandArg()):
+    target_type, value1, value2 = await parse_ec2_target(matcher, args)
+
+    if target_type == "tag":
+        instances = await ec2_manager.get_instances_by_tag(value1, value2, states=['pending', 'running', 'stopping', 'stopped'])
+    else:
+        instances = await ec2_manager.get_instances_by_id([value1], states=['pending', 'running', 'stopping', 'stopped'])
+    if not instances:
+        await matcher.finish("No EC2 instances found for the specified target.")
+    status_list = [format_ec2_status(inst) for inst in instances]
+    await matcher.finish("EC2 Instance Status:\n" + "\n".join(status_list))
+
+
+# ... (omitting other EC2 handlers for brevity, they remain the same)
+
+
+# --- Lightsail Handlers ---
+
+@lightsail_list_matcher.handle()
+@handle_non_finish_exceptions("An error occurred listing Lightsail instances.")
+async def handle_lightsail_list(matcher: Matcher):
+    instances = await lightsail_manager.get_all_instances()
+    if not instances:
+        await matcher.finish("No Lightsail instances found.")
+    
+    def format_lightsail(inst): 
+        return f"- {inst['name']} ({inst['state']['name']})\n  Region: {inst['location']['regionName']}\n  IP: {inst['publicIpAddress']}"
+
+    status_list = [format_lightsail(inst) for inst in instances]
+    await matcher.finish("Lightsail Instances:\n" + "\n".join(status_list))
+
+@lightsail_start_matcher.handle()
+@handle_non_finish_exceptions("An error occurred while starting the Lightsail instance.")
+async def handle_lightsail_start(matcher: Matcher, args: Message = CommandArg()):
+    instance_name = args.extract_plain_text().strip()
+    if not instance_name:
+        await matcher.finish("Please provide a Lightsail instance name.")
+    
+    await matcher.send(f"Sending start command to {instance_name}...\nWaiting for it to become running...")
+    await lightsail_manager.start_instance(instance_name)
+    await lightsail_manager.wait_for_status(instance_name, 'running')
+    await matcher.finish(f"Successfully started Lightsail instance: {instance_name}")
+
+@lightsail_stop_matcher.handle()
+@handle_non_finish_exceptions("An error occurred while stopping the Lightsail instance.")
+async def handle_lightsail_stop(matcher: Matcher, args: Message = CommandArg()):
+    instance_name = args.extract_plain_text().strip()
+    if not instance_name:
+        await matcher.finish("Please provide a Lightsail instance name.")
+    
+    await matcher.send(f"Sending stop command to {instance_name}...\nWaiting for it to become stopped...")
+    await lightsail_manager.stop_instance(instance_name)
+    await lightsail_manager.wait_for_status(instance_name, 'stopped')
+    await matcher.finish(f"Successfully stopped Lightsail instance: {instance_name}")
+
+
+# --- Cost Explorer Handlers ---
+
+@cost_matcher.handle()
+@handle_non_finish_exceptions("An error occurred while fetching AWS cost data.")
+async def handle_cost(matcher: Matcher, args: Message = CommandArg()):
+    sub_command = args.extract_plain_text().strip()
+    
+    if sub_command == "today":
+        result = await cost_manager.get_cost_today()
+        cost = result['ResultsByTime'][0]['Total']['UnblendedCost']
+        await matcher.finish(f"AWS cost for today: {float(cost['Amount']):.4f} {cost['Unit']}")
+    elif sub_command == "month":
+        result = await cost_manager.get_cost_this_month()
+        cost = result['ResultsByTime'][0]['Total']['UnblendedCost']
+        await matcher.finish(f"AWS cost this month: {float(cost['Amount']):.4f} {cost['Unit']}")
+    elif sub_command == "month by_service":
+        result = await cost_manager.get_cost_this_month_by_service()
+        lines = ["Cost this month by service:"]
+        for group in sorted(result['ResultsByTime'][0]['Groups'], key=lambda x: float(x['Metrics']['UnblendedCost']['Amount']), reverse=True):
+            service_name = group['Keys'][0]
+            cost = group['Metrics']['UnblendedCost']
+            if float(cost['Amount']) > 0:
+                lines.append(f"- {service_name}: {float(cost['Amount']):.4f} {cost['Unit']}")
+        await matcher.finish("\n".join(lines))
+    else:
+        await matcher.finish("Invalid cost command. Use: today, month, month by_service")

nonebot_plugin_awsmgmt/config.py

@@ -0,0 +1,14 @@
+from pydantic import BaseModel
+from typing import Optional
+
+class Config(BaseModel):
+    """
+    AWS Management Plugin Configuration
+    """
+    aws_access_key_id: Optional[str] = None
+    aws_secret_access_key: Optional[str] = None
+    aws_region: str = "us-east-1"
+    aws_default_target_tag: Optional[str] = "ManagedBy:nonebot-plugin-awsmgmt"
+
+    class Config:
+        extra = "ignore"

nonebot_plugin_awsmgmt/cost_explorer_manager.py

@@ -0,0 +1,51 @@
+import aioboto3
+from datetime import datetime, date, timedelta
+from typing import Dict, Any, List
+
+from .config import Config
+
+class CostExplorerManager:
+    def __init__(self, config: Config):
+        self.config = config
+        # Cost Explorer is only available in us-east-1, but we use the session region for authentication
+        self.session = aioboto3.Session(
+            aws_access_key_id=self.config.aws_access_key_id,
+            aws_secret_access_key=self.config.aws_secret_access_key,
+            region_name=self.config.aws_region,
+        )
+
+    async def _get_cost(self, start_date: str, end_date: str, granularity: str, group_by: List[Dict[str, str]] = None) -> Dict[str, Any]:
+        async with self.session.client("ce", region_name="us-east-1") as ce:
+            kwargs = {
+                "TimePeriod": {"Start": start_date, "End": end_date},
+                "Granularity": granularity,
+                "Metrics": ["UnblendedCost"],
+            }
+            if group_by:
+                kwargs["GroupBy"] = group_by
+            return await ce.get_cost_and_usage(**kwargs)
+
+    async def get_cost_today(self) -> Dict[str, Any]:
+        """Fetches the cost for today."""
+        today = date.today()
+        start_of_day = today.isoformat()
+        end_of_day = (today + timedelta(days=1)).isoformat()
+        return await self._get_cost(start_of_day, end_of_day, "DAILY")
+
+    async def get_cost_this_month(self) -> Dict[str, Any]:
+        """Fetches the cost for the current month."""
+        today = date.today()
+        start_of_month = today.replace(day=1).isoformat()
+        # The end date is exclusive, so we use the first day of the next month
+        next_month = (today.replace(day=28) + timedelta(days=4)).replace(day=1)
+        end_of_month = next_month.isoformat()
+        return await self._get_cost(start_of_month, end_of_month, "MONTHLY")
+
+    async def get_cost_this_month_by_service(self) -> Dict[str, Any]:
+        """Fetches the cost for the current month, grouped by service."""
+        today = date.today()
+        start_of_month = today.replace(day=1).isoformat()
+        next_month = (today.replace(day=28) + timedelta(days=4)).replace(day=1)
+        end_of_month = next_month.isoformat()
+        group_by = [{"Type": "DIMENSION", "Key": "SERVICE"}]
+        return await self._get_cost(start_of_month, end_of_month, "MONTHLY", group_by=group_by)

nonebot_plugin_awsmgmt/ec2_manager.py

@@ -0,0 +1,71 @@
+import aioboto3
+from typing import List, Dict, Any
+from .config import Config
+
+class EC2Manager:
+    def __init__(self, config: Config):
+        self.config = config
+        self.session = aioboto3.Session(
+            aws_access_key_id=self.config.aws_access_key_id,
+            aws_secret_access_key=self.config.aws_secret_access_key,
+            region_name=self.config.aws_region,
+        )
+
+    async def get_instances_by_tag(self, tag_key: str, tag_value: str, states: List[str] = ['running', 'stopped']) -> List[Dict[str, Any]]:
+        """Finds EC2 instances based on a specific tag."""
+        instances = []
+        async with self.session.client("ec2") as ec2:
+            paginator = ec2.get_paginator('describe_instances')
+            async for page in paginator.paginate(
+                Filters=[
+                    {'Name': f'tag:{tag_key}', 'Values': [tag_value]},
+                    {'Name': 'instance-state-name', 'Values': states}
+                ]
+            ):
+                for reservation in page['Reservations']:
+                    for instance in reservation['Instances']:
+                        instances.append(instance)
+        return instances
+
+    async def get_instances_by_id(self, instance_ids: List[str], states: List[str] = ['running', 'stopped']) -> List[Dict[str, Any]]:
+        """Finds EC2 instances based on a list of IDs."""
+        instances = []
+        async with self.session.client("ec2") as ec2:
+            paginator = ec2.get_paginator('describe_instances')
+            async for page in paginator.paginate(
+                InstanceIds=instance_ids,
+                Filters=[{'Name': 'instance-state-name', 'Values': states}]
+            ):
+                for reservation in page['Reservations']:
+                    for instance in reservation['Instances']:
+                        instances.append(instance)
+        return instances
+
+    async def start_instances(self, instance_ids: List[str]) -> Dict[str, Any]:
+        """Starts the specified EC2 instances."""
+        if not instance_ids:
+            return {"StartingInstances": []}
+        async with self.session.client("ec2") as ec2:
+            return await ec2.start_instances(InstanceIds=instance_ids)
+
+    async def stop_instances(self, instance_ids: List[str]) -> Dict[str, Any]:
+        """Stops the specified EC2 instances."""
+        if not instance_ids:
+            return {"StoppingInstances": []}
+        async with self.session.client("ec2") as ec2:
+            return await ec2.stop_instances(InstanceIds=instance_ids)
+
+    async def reboot_instances(self, instance_ids: List[str]) -> Dict[str, Any]:
+        """Reboots the specified EC2 instances."""
+        if not instance_ids:
+            return {}
+        async with self.session.client("ec2") as ec2:
+            return await ec2.reboot_instances(InstanceIds=instance_ids)
+
+    async def wait_for_status(self, instance_ids: List[str], status: str):
+        """Waits for instances to reach a specific status."""
+        if not instance_ids:
+            return
+        async with self.session.client("ec2") as ec2:
+            waiter = ec2.get_waiter(status)
+            await waiter.wait(InstanceIds=instance_ids)

nonebot_plugin_awsmgmt/lightsail_manager.py

@@ -0,0 +1,43 @@
+import asyncio
+import aioboto3
+from typing import List, Dict, Any
+
+from .config import Config
+
+class LightsailManager:
+    def __init__(self, config: Config):
+        self.config = config
+        self.session = aioboto3.Session(
+            aws_access_key_id=self.config.aws_access_key_id,
+            aws_secret_access_key=self.config.aws_secret_access_key,
+            region_name=self.config.aws_region,
+        )
+
+    async def get_all_instances(self) -> List[Dict[str, Any]]:
+        """Gets a list of all Lightsail instances."""
+        async with self.session.client("lightsail") as lightsail:
+            response = await lightsail.get_instances()
+            return response.get('instances', [])
+
+    async def start_instance(self, instance_name: str) -> Dict[str, Any]:
+        """Starts a specific Lightsail instance."""
+        async with self.session.client("lightsail") as lightsail:
+            return await lightsail.start_instance(instanceName=instance_name)
+
+    async def stop_instance(self, instance_name: str) -> Dict[str, Any]:
+        """Stops a specific Lightsail instance."""
+        async with self.session.client("lightsail") as lightsail:
+            return await lightsail.stop_instance(instanceName=instance_name)
+
+    async def wait_for_status(self, instance_name: str, target_status: str, timeout: int = 300, delay: int = 15):
+        """Waits for a lightsail instance to reach a specific status."""
+        async with self.session.client("lightsail") as lightsail:
+            elapsed_time = 0
+            while elapsed_time < timeout:
+                response = await lightsail.get_instance(instanceName=instance_name)
+                instance = response.get('instance')
+                if instance and instance.get('state', {}).get('name') == target_status:
+                    return
+                await asyncio.sleep(delay)
+                elapsed_time += delay
+            raise asyncio.TimeoutError(f"Instance {instance_name} did not reach {target_status} within {timeout} seconds.")

{nonebot_plugin_awsmgmt-0.1.0.dist-info → nonebot_plugin_awsmgmt-0.1.1.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.3
 Name: nonebot-plugin-awsmgmt
-Version: 0.1.0
-Summary: Add your description here
+Version: 0.1.1
+Summary: A nonebot2 plugin for managing AWS EC2, Lightsail, and Cost Explorer via commands.
 Author-email: Maximilian Wu <me@maxng.cc>
 Requires-Python: >=3.8
 Requires-Dist: aioboto3>=15.0.0

nonebot_plugin_awsmgmt-0.1.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+nonebot_plugin_awsmgmt/__init__.py,sha256=GVN4az13jO2EghO0OrqBA_qM_tkxLVHK5ZekqNuvN8s,8347
+nonebot_plugin_awsmgmt/config.py,sha256=tI5-JmakhKmxWtTv5qeTpszsHyJGJW1X48Q278HC0a8,389
+nonebot_plugin_awsmgmt/cost_explorer_manager.py,sha256=dppD4EE8YZzhAx0mCgftMPoBNSSLwdBNA6t4L7Hnfts,2394
+nonebot_plugin_awsmgmt/ec2_manager.py,sha256=BIpHV8jo8nBQotePWa31mcNRwl14pL7mQZodXAK3p8Y,3200
+nonebot_plugin_awsmgmt/lightsail_manager.py,sha256=GEbrQAihLucVfF1XyJgvtsig_yCBedH1GyoBgPkIrCo,2025
+nonebot_plugin_awsmgmt-0.1.1.dist-info/METADATA,sha256=ts2Lx5PMnPj4udvIohSnfKiqyYIpmf-wpITZSPpan3Y,3684
+nonebot_plugin_awsmgmt-0.1.1.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+nonebot_plugin_awsmgmt-0.1.1.dist-info/RECORD,,

nonebot_plugin_awsmgmt-0.1.0.dist-info/RECORD

@@ -1,4 +0,0 @@
-nonebot_plugin_awsmgmt/__init__.py,sha256=3-7xXlyyH7iTXdZ36lyytnJrIKWLXvUbj_45Hnuk6Bg,68
-nonebot_plugin_awsmgmt-0.1.0.dist-info/METADATA,sha256=TPx99HgE1bSoNopTx5aUI12DELDpn4j9QHEUtHWREkw,3627
-nonebot_plugin_awsmgmt-0.1.0.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-nonebot_plugin_awsmgmt-0.1.0.dist-info/RECORD,,