pycfdp 0.2.2__py3-none-any.whl

cfdp/event.py

@@ -0,0 +1,55 @@
+class Event:
+    def __init__(self, transaction, type, pdu=None, checksum=None):
+        self.transaction = transaction
+        self.type = type
+        # Inbound-PDU payload for a PDU-driven (receive-side) machine. The pure
+        # machine contract has a single input door, ``update_state(event)``, so
+        # everything the machine needs — including the triggering PDU — rides on
+        # the event (design "The machine contract").
+        self.pdu = pdu
+        # Result payload for the async-checksum channel (design R1 / issue #21).
+        # A ``RequestChecksum`` effect is computed off the event thread by the
+        # shell's checksum service, which injects an ``E42_CHECKSUM_READY`` event
+        # carrying the computed value here. The single input door still holds:
+        # the machine reads the result off the event, never from a return value.
+        self.checksum = checksum
+
+
+class EventType:
+    E0_ENTERED_STATE = "ENTERED_STATE"
+    E1_SEND_FILE_DATA = "SEND_FILE_DATA"
+    E2_ABANDON_TRANSACTION = "ABANDON_TRANSACTION"
+    E3_NOTICE_OF_CANCELLATION = "NOTICE_OF_CANCELLATION"
+    E4_NOTICE_OF_SUSPENSION = "NOTICE_OF_SUSPENSION"
+    E5_SUSPEND_TIMERS = "SUSPEND_TIMERS"
+    E6_RESUME_TIMERS = "RESUME_TIMERS"
+
+    E10_RECEIVED_METADATA = "RECEIVED_METADATA"
+    E11_RECEIVED_FILEDATA = "RECEIVED_FILEDATA"
+    E12_RECEIVED_EOF_NO_ERROR = "RECEIVED_EOF_NO_ERROR"
+    E13_RECEIVED_EOF_CANCEL = "RECEIVED_EOF_CANCEL"
+    E14_RECEIVED_ACK_EOF = "RECEIVED_ACK_EOF"
+    E15_RECEIVED_NAK = "RECEIVED_NAK"
+    E16_RECEIVED_FINISHED_NO_ERROR = "RECEIVED_FINISHED_NO_ERROR"
+    E17_RECEIVED_FINISHED_CANCEL = "RECEIVED_FINISHED_CANCEL"
+    E18_RECEIVED_ACK_FINISHED = "RECEIVED_ACK_FINISHED"
+
+    E25_ACK_TIMEOUT = "ACK_TIMEOUT"
+    E26_NAK_TIMEOUT = "NAK_TIMEOUT"
+    E27_INACTIVITY_TIMEOUT = "INACTIVITY_TIMEOUT"
+
+    E30_RECEIVED_PUT_REQUEST = "RECEIVED_PUT_REQUEST"
+    E31_RECEIVED_SUSPEND_REQUEST = "RECEIVED_SUSPEND_REQUEST"
+    E32_RECEIVED_RESUME_REQUEST = "RECEIVED_RESUME_REQUEST"
+    E33_RECEIVED_CANCEL_REQUEST = "RECEIVED_CANCEL_REQUEST"
+    E34_RECEIVED_REPORT_REQUEST = "RECEIVED_REPORT_REQUEST"
+
+    E40_RECEIVED_FREEZE = "RECEIVED_FREEZE"
+    E41_RECEIVED_THAW = "RECEIVED_THAW"
+
+    # Async-checksum result (design R1 / issue #21). Injected by the shell's
+    # checksum service once a ``RequestChecksum`` effect has been computed off
+    # the event thread; the computed value rides on ``event.checksum``. The old
+    # machines never see this event (they compute checksum synchronously via
+    # ``Transaction.get_file_checksum``); it exists only on the pure stack.
+    E42_CHECKSUM_READY = "CHECKSUM_READY"

cfdp/filestore/__init__.py

@@ -0,0 +1,2 @@
+from .base import FileHandle, VirtualFileStore
+from .native import NativeFileStore

cfdp/filestore/base.py

@@ -0,0 +1,99 @@
+from abc import ABC, abstractmethod
+
+
+class FileHandle(ABC):
+    """
+    Abstract base class for file handle objects returned by VirtualFileStore.open()
+    and VirtualFileStore.open_tempfile(). Implementations must provide all listed
+    abstract methods.
+    """
+
+    @abstractmethod
+    def seek(self, offset, whence=0): ...
+
+    @abstractmethod
+    def tell(self): ...
+
+    @abstractmethod
+    def read(self, n=-1) -> bytes: ...
+
+    @abstractmethod
+    def write(self, data: bytes): ...
+
+    @abstractmethod
+    def close(self): ...
+
+    @abstractmethod
+    def calculate_checksum(self, checksum_type: int) -> int: ...
+
+
+class VirtualFileStore(ABC):
+    """
+    The Virtual File Store (VFS) is an abstraction of file system. An
+    implementation must provide the methods listed below.
+
+    An implementation can map the VFS to a platform dependent native file
+    system or a packet store for example.
+
+    The VFS starts at root '/' and uses slashes for subfolders. This is how
+    pathes are to be passed to CFDP methods (eg. Put Request, Filestore
+    Requests, and Directory Listings.)
+
+    Example: '/files/a_file.txt'
+
+    """
+
+    def __init__(self):
+        self.config = None
+
+    @abstractmethod
+    def create_file(self, filepath):
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete_file(self, filepath):
+        raise NotImplementedError
+
+    @abstractmethod
+    def rename_file(self, filepath1, filepath2):
+        raise NotImplementedError
+
+    @abstractmethod
+    def append_file(self, filepath1, filepath2):
+        raise NotImplementedError
+
+    @abstractmethod
+    def replace_file(self, filepath1, filepath2):
+        raise NotImplementedError
+
+    @abstractmethod
+    def create_directory(self, dirpath):
+        raise NotImplementedError
+
+    @abstractmethod
+    def remove_directory(self, dirpath):
+        raise NotImplementedError
+
+    @abstractmethod
+    def list_directory(self, dirpath):
+        raise NotImplementedError
+
+    @abstractmethod
+    def open(self, filepath, mode="rb"):
+        raise NotImplementedError
+
+    @abstractmethod
+    def open_tempfile(self):
+        raise NotImplementedError
+
+    @abstractmethod
+    def is_file(self, filepath):
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_size(self, filepath):
+        raise NotImplementedError
+
+    @abstractmethod
+    def join_path(self, *args):
+        raise NotImplementedError

cfdp/filestore/native.py

@@ -0,0 +1,162 @@
+import os
+import shutil
+import tempfile
+
+from .base import FileHandle, VirtualFileStore
+
+
+class NativeFileStore(VirtualFileStore):
+    """
+    The Native File Store implements the Virtual File Store as a platform
+    dependent file system, using the Python 'os.path' library.
+
+    A rootpath is provided as class instantiation. The VFS paths are then
+    relative to this root path. For example, if root path is '/home/demo'
+    and a Put Request places a file to '/files/small.txt', then this will
+    land in '/home/demo/files/small.txt'.
+
+    """
+
+    def __init__(self, rootpath):
+        super().__init__()
+        self.rootpath = os.path.realpath(rootpath)
+
+    def get_native_path(self, path):
+        # convert from virtual filestore path to absolute native path
+        path_items = path.split("/")
+        path_items = [x for x in path_items if x != ""]
+        if path_items:
+            joined = os.path.join(*path_items)
+        else:
+            joined = ""
+        native = os.path.realpath(os.path.join(self.rootpath, joined))
+        if native != self.rootpath and not native.startswith(self.rootpath + os.sep):
+            raise ValueError(
+                f"Path traversal detected: {path!r} escapes filestore root"
+            )
+        return native
+
+    def get_virtual_path(self, path):
+        # convert from native relative path to virtual path
+        path = "/".join(os.path.normpath(path).split(os.path.sep))
+        if not path.startswith("/"):
+            path = "/" + path
+        return path
+
+    def create_file(self, filepath):
+        NativeFileHandle(self.get_native_path(filepath), "wb").close()
+
+    def delete_file(self, filepath):
+        os.remove(self.get_native_path(filepath))
+
+    def rename_file(self, filepath1, filepath2):
+        os.rename(self.get_native_path(filepath1), self.get_native_path(filepath2))
+
+    def append_file(self, filepath1, filepath2):
+        fh1 = open(self.get_native_path(filepath1), "ab")
+        fh2 = open(self.get_native_path(filepath2), "rb")
+        fh1.write(fh2.read())
+        fh1.close()
+        fh2.close()
+
+    def replace_file(self, filepath1, filepath2):
+        fh1 = open(self.get_native_path(filepath1), "wb")
+        fh2 = open(self.get_native_path(filepath2), "rb")
+        fh1.write(fh2.read())
+        fh1.close()
+        fh2.close()
+
+    def create_directory(self, dirpath):
+        os.mkdir(self.get_native_path(dirpath))
+
+    def remove_directory(self, dirpath):
+        shutil.rmtree(self.get_native_path(dirpath))
+
+    def list_directory(self, dirpath):
+        # create directory listing
+        dirpath = self.get_native_path(dirpath)
+        # get the full path w.r.t to host file system
+        dirpath, dirnames, filenames = next(os.walk(dirpath))
+
+        listing = "type,path,size,timestamp\n"
+        for dirname in dirnames:
+            fullpath = os.path.join(dirpath, dirname)
+            relpath = os.path.relpath(fullpath, self.rootpath)
+            line = "{},{},{},{}\n".format(
+                "d",
+                self.get_virtual_path(relpath),
+                os.path.getsize(fullpath),
+                os.path.getmtime(fullpath),
+            )
+            listing += line
+        for filename in filenames:
+            fullpath = os.path.join(dirpath, filename)
+            relpath = os.path.relpath(fullpath, self.rootpath)
+            line = "{},{},{},{}\n".format(
+                "f",
+                self.get_virtual_path(relpath),
+                os.path.getsize(fullpath),
+                os.path.getmtime(fullpath),
+            )
+            listing += line
+        return listing
+
+    def open(self, filepath, mode="rb"):
+        return NativeFileHandle(self.get_native_path(filepath), mode)
+
+    def open_tempfile(self):
+        return NativeTemporaryFileHandle()
+
+    def is_file(self, filepath):
+        return os.path.isfile(self.get_native_path(filepath))
+
+    def get_size(self, filepath):
+        return os.path.getsize(self.get_native_path(filepath))
+
+    def join_path(self, *args):
+        return "/".join(args)
+
+
+class NativeFileHandle(FileHandle):
+    """
+    The NativeFileHandle provides a generic interface to Python's 'open'
+    function. It also implements method for calculating the file checksum.
+
+    """
+
+    def __init__(self, filepath, mode="rb"):
+        self.handle = open(filepath, mode)
+
+    def seek(self, *args, **kwargs):
+        return self.handle.seek(*args, **kwargs)
+
+    def tell(self, *args, **kwargs):
+        return self.handle.tell(*args, **kwargs)
+
+    def read(self, *args, **kwargs):
+        return self.handle.read(*args, **kwargs)
+
+    def write(self, *args, **kwargs):
+        return self.handle.write(*args, **kwargs)
+
+    def close(self, *args, **kwargs):
+        return self.handle.close(*args, **kwargs)
+
+    def calculate_checksum(self, checksum_type: int) -> int:
+        from cfdp.checksum import calculate_checksum as _calc
+
+        self.handle.seek(0)
+
+        def _chunks():
+            while True:
+                chunk = self.handle.read(65536)
+                if not chunk:
+                    break
+                yield chunk
+
+        return _calc(_chunks(), checksum_type)
+
+
+class NativeTemporaryFileHandle(NativeFileHandle):
+    def __init__(self):
+        self.handle = tempfile.TemporaryFile()

cfdp/meta/__init__.py

@@ -0,0 +1,3 @@
+from .datafield import *
+from .filestore import *
+from .message import *

cfdp/meta/datafield.py

@@ -0,0 +1,11 @@
+class TypeLengthValue:
+    def encode(self):
+        type = self.type
+        length = len(self.value)
+        value = self.value
+
+        databytes = bytearray()
+        databytes.append(type)
+        databytes.append(length)
+        databytes += value
+        return databytes

cfdp/meta/filestore.py

@@ -0,0 +1,127 @@
+from cfdp import logger
+from cfdp.constants import ActionCode, TypeFieldCode
+
+from .datafield import TypeLengthValue
+
+
+class FilestoreRequest(TypeLengthValue):
+    def __init__(self, action_code, first_filename, second_filename=None):
+        self.type = TypeFieldCode.FILESTORE_REQUEST
+
+        self.action_code = action_code
+        self.first_filename = first_filename
+        self.second_filename = second_filename
+
+    def encode(self):
+        data = bytes([(self.action_code << 4)])
+
+        value = self.first_filename.encode("utf-8")
+        length = len(value)
+        data += bytes([length])
+        data += value
+
+        if self.second_filename:
+            value = self.second_filename.encode("utf-8")
+            length = len(value)
+            data += bytes([length])
+            data += value
+
+        self.value = data
+        return super().encode()
+
+
+def execute_filestore_requests(kernel, filestore_requests):
+    for filestore_request in filestore_requests:
+        if filestore_request.action_code == ActionCode.CREATE_FILE:
+            filename = filestore_request.first_filename.decode()
+            logger.info(f"Create file: <{filename}>")
+            try:
+                kernel.filestore.create_file(filename)
+            except Exception:
+                logger.error(f"Failed to create file <{filename}>")
+
+        elif filestore_request.action_code == ActionCode.DELETE_FILE:
+            filename = filestore_request.first_filename.decode()
+            logger.info(f"Delete file: <{filename}>")
+            try:
+                kernel.filestore.delete_file(filename)
+            except Exception:
+                logger.error(f"Failed to delete file: <{filename}>")
+
+        elif filestore_request.action_code == ActionCode.RENAME_FILE:
+            filename1 = filestore_request.first_filename.decode()
+            filename2 = filestore_request.second_filename.decode()
+            logger.info(f"Rename file: <{filename1}> to <{filename2}>")
+            try:
+                kernel.filestore.rename_file(filename1, filename2)
+            except Exception:
+                logger.error(f"Failed to rename file <{filename1}> to <{filename2}>")
+
+        elif filestore_request.action_code == ActionCode.APPEND_FILE:
+            filename1 = filestore_request.first_filename.decode()
+            filename2 = filestore_request.second_filename.decode()
+            logger.info(f"Append file <{filename1}> with <{filename2}>")
+            try:
+                kernel.filestore.append_file(filename1, filename2)
+            except Exception:
+                logger.error(f"Failed to append file <{filename1}> with <{filename2}>")
+
+        elif filestore_request.action_code == ActionCode.REPLACE_FILE:
+            filename1 = filestore_request.first_filename.decode()
+            filename2 = filestore_request.second_filename.decode()
+            logger.info(f"Replace content of file <{filename1}> by <{filename2}>")
+            try:
+                kernel.filestore.replace_file(filename1, filename2)
+            except Exception:
+                logger.error(
+                    f"Failed to replace content of <{filename1}> by <{filename2}>"
+                )
+
+        elif filestore_request.action_code == ActionCode.CREATE_DIRECTORY:
+            dirname = filestore_request.first_filename.decode()
+            logger.info(f"Create directory: <{dirname}>")
+            try:
+                kernel.filestore.create_directory(dirname)
+            except Exception:
+                logger.error(f"Failed to create directory: <{dirname}>")
+
+        elif filestore_request.action_code == ActionCode.REMOVE_DIRECTORY:
+            dirname = filestore_request.first_filename.decode()
+            logger.info(f"Remove directory: <{dirname}>")
+            try:
+                kernel.filestore.remove_directory(dirname)
+            except Exception:
+                logger.error(f"Failed to delete directory: <{dirname}>")
+
+        elif filestore_request.action_code == ActionCode.DENY_FILE:
+            filename = filestore_request.first_filename.decode()
+            logger.info(f"Deny file: <{filename}>")
+            try:
+                kernel.filestore.delete_file(filename)
+            except Exception:
+                pass
+
+        elif filestore_request.action_code == ActionCode.DENY_DIRECTORY:
+            dirname = filestore_request.first_filename.decode()
+            logger.info(f"Deny directory: <{dirname}>")
+            try:
+                kernel.filestore.remove_directory(dirname)
+            except Exception:
+                pass
+
+
+def extract_filestore_request(data):
+    action_code = data[0] >> 4
+    length_of_first_filename = data[1]
+    first_filename = data[2 : 2 + length_of_first_filename]
+
+    if action_code in [
+        ActionCode.RENAME_FILE,
+        ActionCode.APPEND_FILE,
+        ActionCode.REPLACE_FILE,
+    ]:
+        second_filename = data[3 + length_of_first_filename :]
+    else:
+        second_filename = None
+
+    return FilestoreRequest(action_code, first_filename, second_filename)