:py:mod:`dissect.target.loaders.remote`
=======================================

.. py:module:: dissect.target.loaders.remote




Module Contents
---------------

Classes
~~~~~~~

.. autoapisummary::

   dissect.target.loaders.remote.RemoteStream
   dissect.target.loaders.remote.RemoteStreamConnection
   dissect.target.loaders.remote.RemoteLoader




Attributes
~~~~~~~~~~

.. autoapisummary::

   dissect.target.loaders.remote.log


.. py:data:: log

.. py:class:: RemoteStream(stream: RemoteStreamConnection, disk_id: int, size: int | None = None)

   Bases: :py:obj:`dissect.util.stream.AlignedStream`


   Basic buffered stream that provides aligned reads.

   Must be subclassed for various stream implementations. Subclasses can implement:
       - :meth:`~AlignedStream._read`
       - :meth:`~AlignedStream._seek`

   The offset and length for ``_read`` are guaranteed to be aligned for streams of a known size.
   If your stream has an unknown size (i.e. ``size == None``), reads of length ``-1`` (i.e. read until EOF) will be
   passed through to your implementation of ``_read``.
   The only time that overriding ``_seek`` would make sense is if there's no known size of your stream,
   but still want to provide ``SEEK_END`` functionality.

   Most subclasses of ``AlignedStream`` take one or more file-like objects as source.
   Operations on these subclasses, like reading, will modify the source file-like object as a side effect.

   :param size: The size of the stream. This is used in read and seek operations. ``None`` if unknown.
   :param align: The alignment size. Read operations are aligned on this boundary. Also determines buffer size.

   .. automethod:: _read
   .. automethod:: _seek


   .. py:attribute:: stream


   .. py:attribute:: disk_id


.. py:class:: RemoteStreamConnection(hostname: str, port: int, **kwargs)

   .. py:attribute:: MAX_RECONNECTS
      :value: 30



   .. py:attribute:: MAX_SHORT_READS
      :value: 10



   .. py:attribute:: RECONNECT_WAIT
      :value: 10



   .. py:attribute:: SOCKET_TIMEOUT
      :value: 30



   .. py:attribute:: COMMAND_INFO
      :value: 1



   .. py:attribute:: COMMAND_QUIT
      :value: 2



   .. py:attribute:: COMMAND_READ
      :value: 50



   .. py:attribute:: CONFIG_KEY
      :value: None



   .. py:attribute:: CONFIG_CRT
      :value: None



   .. py:method:: configure(key: str, crt: str) -> None
      :staticmethod:



   .. py:attribute:: hostname


   .. py:attribute:: port


   .. py:attribute:: log


   .. py:method:: is_connected() -> bool


   .. py:method:: connect() -> None


   .. py:method:: read(disk_id: int, offset: int, length: int) -> bytes


   .. py:method:: close() -> None


   .. py:method:: info() -> list[RemoteStream]


.. py:class:: RemoteLoader(path: pathlib.Path, parsed_path: urllib.parse.ParseResult | None = None)

   Bases: :py:obj:`dissect.target.loader.Loader`


   Load a remote target that runs a compatible Dissect agent.


   .. py:attribute:: stream


   .. py:method:: detect(path: pathlib.Path) -> bool
      :staticmethod:


      Detects wether this ``Loader`` class can load this specific ``path``.

      :param path: The target path to check.

      :returns: ``True`` if the ``path`` can be loaded by a ``Loader`` instance. ``False`` otherwise.



   .. py:method:: map(target: dissect.target.target.Target) -> None

      Maps the loaded path into a ``Target``.

      :param target: The target that we're mapping into.