Fix missing try/catch on all get_message()

src/aleph_client/commands/instance/__init__.py

@@ -282,23 +282,31 @@ async def create(
 
     # Validate rootfs message exist
     async with AlephHttpClient(api_server=settings.API_HOST) as client:
-        rootfs_message: StoreMessage = await client.get_message(item_hash=rootfs, message_type=StoreMessage)
-        if not rootfs_message:
+        rootfs_message: Optional[StoreMessage] = None
+        try:
+            rootfs_message = await client.get_message(item_hash=rootfs, message_type=StoreMessage)
+        except MessageNotFoundError:
             echo("Given rootfs volume does not exist on aleph.im")
+        except ForgottenMessageError:
+            echo("Given rootfs volume has been deleted on aleph.im")
+        if not rootfs_message:
             raise typer.Exit(code=1)
-        if rootfs_size is None and rootfs_message.content.size:
-            rootfs_size = rootfs_message.content.size
+        elif rootfs_size is None:
+            rootfs_size = safe_getattr(rootfs_message, "content.size")
 
     # Validate confidential firmware message exist
     confidential_firmware_as_hash = None
     if confidential:
         async with AlephHttpClient(api_server=settings.API_HOST) as client:
             confidential_firmware_as_hash = ItemHash(confidential_firmware)
-            firmware_message: StoreMessage = await client.get_message(
-                item_hash=confidential_firmware, message_type=StoreMessage
-            )
-            if not firmware_message:
+            firmware_message: Optional[StoreMessage] = None
+            try:
+                firmware_message = await client.get_message(item_hash=confidential_firmware, message_type=StoreMessage)
+            except MessageNotFoundError:
                 echo("Confidential Firmware hash does not exist on aleph.im")
+            except ForgottenMessageError:
+                echo("Confidential Firmware hash has been deleted on aleph.im")
+            if not firmware_message:
                 raise typer.Exit(code=1)
 
     name = name or validated_prompt("Instance name", lambda x: len(x) < 65)
@@ -469,6 +477,9 @@ async def create(
                 f"{account.get_address()} on {account.CHAIN} has {e.available_funds} ALEPH but needs {e.required_funds} ALEPH."
             )
             raise typer.Exit(code=1)
+        except Exception as e:
+            echo(f"Instance creation failed:\n{e}")
+            raise typer.Exit(code=1)
         if print_message:
             echo(f"{message.json(indent=4)}")
 

src/aleph_client/commands/instance/network.py

@@ -8,11 +8,14 @@
 import aiohttp
 from aleph.sdk import AlephHttpClient
 from aleph.sdk.conf import settings
+from aleph.sdk.exceptions import ForgottenMessageError, MessageNotFoundError
 from aleph.sdk.utils import safe_getattr
 from aleph_message.models import InstanceMessage
 from aleph_message.models.execution.base import PaymentType
 from aleph_message.models.item_hash import ItemHash
+from click import echo
 from pydantic import ValidationError
+from typer import Exit
 
 from aleph_client.commands import help_strings
 from aleph_client.commands.node import NodeInfo, _fetch_nodes
@@ -141,7 +144,15 @@ async def fetch_vm_info(message: InstanceMessage, node_list: NodeInfo) -> tuple[
 
 async def find_crn_of_vm(vm_id: str) -> Optional[str]:
     async with AlephHttpClient(api_server=settings.API_HOST) as client:
-        message: InstanceMessage = await client.get_message(item_hash=ItemHash(vm_id), message_type=InstanceMessage)
+        message: Optional[InstanceMessage] = None
+        try:
+            message = await client.get_message(item_hash=ItemHash(vm_id), message_type=InstanceMessage)
+        except MessageNotFoundError:
+            echo("Instance does not exist on aleph.im")
+        except ForgottenMessageError:
+            echo("Instance has been deleted on aleph.im")
+        if not message:
+            raise Exit(code=1)
         node_list: NodeInfo = await _fetch_nodes()
         _, info = await fetch_vm_info(message, node_list)
         is_valid = info["crn_url"] not in [help_strings.CRN_PENDING, help_strings.CRN_UNKNOWN]

src/aleph_client/commands/message.py

@@ -14,6 +14,7 @@
 from aleph.sdk import AlephHttpClient, AuthenticatedAlephHttpClient
 from aleph.sdk.account import _load_account
 from aleph.sdk.conf import settings
+from aleph.sdk.exceptions import ForgottenMessageError, MessageNotFoundError
 from aleph.sdk.query.filters import MessageFilter
 from aleph.sdk.query.responses import MessagesResponse
 from aleph.sdk.types import AccountFromPrivateKey, StorageEnum
@@ -42,13 +43,20 @@ async def get(
     item_hash: str = typer.Argument(..., help="Item hash of the message"),
 ):
     async with AlephHttpClient(api_server=settings.API_HOST) as client:
-        message, status = await client.get_message(item_hash=ItemHash(item_hash), with_status=True)
-        typer.echo(f"Message Status: {colorized_status(status)}")
-        if status == MessageStatus.REJECTED:
-            reason = await client.get_message_error(item_hash=ItemHash(item_hash))
-            typer.echo(colorful_json(json.dumps(reason, indent=4)))
-        else:
-            typer.echo(colorful_message_json(message))
+        message: Optional[AlephMessage] = None
+        try:
+            message, status = await client.get_message(item_hash=ItemHash(item_hash), with_status=True)
+        except MessageNotFoundError:
+            typer.echo("Message does not exist on aleph.im")
+        except ForgottenMessageError:
+            typer.echo("Message has been forgotten on aleph.im")
+        if message:
+            typer.echo(f"Message Status: {colorized_status(status)}")
+            if status == MessageStatus.REJECTED:
+                reason = await client.get_message_error(item_hash=ItemHash(item_hash))
+                typer.echo(colorful_json(json.dumps(reason, indent=4)))
+            else:
+                typer.echo(colorful_message_json(message))
 
 
 @app.command()
@@ -173,41 +181,47 @@ async def amend(
     account: AccountFromPrivateKey = _load_account(private_key, private_key_file)
 
     async with AlephHttpClient(api_server=settings.API_HOST) as client:
-        existing_message: AlephMessage = await client.get_message(item_hash=item_hash)
-
-    editor: str = os.getenv("EDITOR", default="nano")
-    with tempfile.NamedTemporaryFile(suffix="json") as fd:
-        # Fill in message template
-        fd.write(existing_message.content.json(indent=4).encode())
-        fd.seek(0)
-
-        # Launch editor
-        subprocess.run([editor, fd.name], check=True)
-
-        # Read new message
-        fd.seek(0)
-        new_content_json = fd.read()
-
-    content_type = type(existing_message).__annotations__["content"]
-    new_content_dict = json.loads(new_content_json)
-    new_content = content_type(**new_content_dict)
-
-    if isinstance(existing_message, ProgramMessage):
-        new_content.replaces = existing_message.item_hash
-    else:
-        new_content.ref = existing_message.item_hash
-
-    new_content.time = time.time()
-    new_content.type = "amend"
-
-    typer.echo(new_content)
-    async with AuthenticatedAlephHttpClient(account=account, api_server=settings.API_HOST) as client:
-        message, status, response = await client.submit(
-            content=new_content.dict(),
-            message_type=existing_message.type,
-            channel=existing_message.channel,
-        )
-    typer.echo(f"{message.json(indent=4)}")
+        existing_message: Optional[AlephMessage] = None
+        try:
+            existing_message = await client.get_message(item_hash=item_hash)
+        except MessageNotFoundError:
+            typer.echo("Message does not exist on aleph.im")
+        except ForgottenMessageError:
+            typer.echo("Message has been forgotten on aleph.im")
+        if existing_message:
+            editor: str = os.getenv("EDITOR", default="nano")
+            with tempfile.NamedTemporaryFile(suffix="json") as fd:
+                # Fill in message template
+                fd.write(existing_message.content.json(indent=4).encode())
+                fd.seek(0)
+
+                # Launch editor
+                subprocess.run([editor, fd.name], check=True)
+
+                # Read new message
+                fd.seek(0)
+                new_content_json = fd.read()
+
+            content_type = type(existing_message).__annotations__["content"]
+            new_content_dict = json.loads(new_content_json)
+            new_content = content_type(**new_content_dict)
+
+            if isinstance(existing_message, ProgramMessage):
+                new_content.replaces = existing_message.item_hash
+            else:
+                new_content.ref = existing_message.item_hash
+
+            new_content.time = time.time()
+            new_content.type = "amend"
+
+            typer.echo(new_content)
+            async with AuthenticatedAlephHttpClient(account=account, api_server=settings.API_HOST) as client:
+                message, status, response = await client.submit(
+                    content=new_content.dict(),
+                    message_type=existing_message.type,
+                    channel=existing_message.channel,
+                )
+            typer.echo(f"{message.json(indent=4)}")
 
 
 @app.command()
@@ -241,11 +255,18 @@ async def watch(
     setup_logging(debug)
 
     async with AlephHttpClient(api_server=settings.API_HOST) as client:
-        original: AlephMessage = await client.get_message(item_hash=ref)
-        async for message in client.watch_messages(
-            message_filter=MessageFilter(refs=[ref], addresses=[original.content.address])
-        ):
-            typer.echo(f"{message.json(indent=indent)}")
+        original: Optional[AlephMessage] = None
+        try:
+            original = await client.get_message(item_hash=ref)
+        except MessageNotFoundError:
+            typer.echo("Message does not exist on aleph.im")
+        except ForgottenMessageError:
+            typer.echo("Message has been forgotten on aleph.im")
+        if original:
+            async for message in client.watch_messages(
+                message_filter=MessageFilter(refs=[ref], addresses=[original.content.address])
+            ):
+                typer.echo(f"{message.json(indent=indent)}")
 
 
 @app.command()

src/aleph_client/commands/program.py

@@ -248,18 +248,24 @@ async def update(
         try:
             program_message: ProgramMessage = await client.get_message(item_hash=item_hash, message_type=ProgramMessage)
         except MessageNotFoundError:
-            typer.echo("Program does not exist")
+            typer.echo("Program does not exist on aleph.im")
             return 1
         except ForgottenMessageError:
-            typer.echo("Program has been forgotten")
+            typer.echo("Program has been deleted on aleph.im")
             return 1
         if program_message.sender != account.get_address():
             typer.echo("You are not the owner of this program")
             return 1
 
         code_ref = program_message.content.code.ref
-        code_message: StoreMessage = await client.get_message(item_hash=code_ref, message_type=StoreMessage)
-
+        try:
+            code_message: StoreMessage = await client.get_message(item_hash=code_ref, message_type=StoreMessage)
+        except MessageNotFoundError:
+            typer.echo("Code volume does not exist on aleph.im")
+            return 1
+        except ForgottenMessageError:
+            typer.echo("Code volume has been deleted on aleph.im")
+            return 1
         if encoding != program_message.content.code.encoding:
             logger.error(
                 f"Code must be encoded with the same encoding as the previous version "
@@ -341,10 +347,10 @@ async def delete(
                 item_hash=item_hash, message_type=ProgramMessage
             )
         except MessageNotFoundError:
-            typer.echo("Program does not exist")
+            typer.echo("Program does not exist on aleph.im")
             return 1
         except ForgottenMessageError:
-            typer.echo("Program already forgotten")
+            typer.echo("Program has been already deleted on aleph.im")
             return 1
         if existing_message.sender != account.get_address():
             typer.echo("You are not the owner of this program")
@@ -360,10 +366,10 @@ async def delete(
                 typer.echo("Code volume does not exist. Skipping...")
                 return 1
             except ForgottenMessageError:
-                typer.echo("Code volume already forgotten, Skipping...")
+                typer.echo("Code volume has been already deleted. Skipping...")
                 return 1
             if existing_message.sender != account.get_address():
-                typer.echo("You are not the owner of this code volume, Skipping...")
+                typer.echo("You are not the owner of this code volume. Skipping...")
                 return 1
 
             code_message, _ = await client.forget(
@@ -515,10 +521,10 @@ async def persist(
         try:
             message: ProgramMessage = await client.get_message(item_hash=item_hash, message_type=ProgramMessage)
         except MessageNotFoundError:
-            typer.echo("Program does not exist")
+            typer.echo("Program does not exist on aleph.im")
             return None
         except ForgottenMessageError:
-            typer.echo("Program has been forgotten")
+            typer.echo("Program has been deleted on aleph.im")
             return None
         if message.sender != account.get_address():
             typer.echo("You are not the owner of this program")
@@ -607,10 +613,10 @@ async def unpersist(
         try:
             message: ProgramMessage = await client.get_message(item_hash=item_hash, message_type=ProgramMessage)
         except MessageNotFoundError:
-            typer.echo("Program does not exist")
+            typer.echo("Program does not exist on aleph.im")
             return None
         except ForgottenMessageError:
-            typer.echo("Program has been forgotten")
+            typer.echo("Program has been deleted on aleph.im")
             return None
         if message.sender != account.get_address():
             typer.echo("You are not the owner of this program")