fprime-gds 3.4.0__py3-none-any.whl → 3.4.2__py3-none-any.whl

fastentrypoints.py

@@ -0,0 +1,115 @@
+# noqa: D300,D400
+# Copyright (c) 2016, Aaron Christianson
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# 1. Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in the
+#    documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+# IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+# TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+# TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+"""
+Monkey patch setuptools to write faster console_scripts with this format:
+
+    import sys
+    from mymodule import entry_function
+    sys.exit(entry_function())
+
+This is better.
+
+(c) 2016, Aaron Christianson
+https://github.com/ninjaaron/fast-entry_points
+"""
+import re
+
+from setuptools.command import easy_install
+
+TEMPLATE = r"""
+# -*- coding: utf-8 -*-
+# EASY-INSTALL-ENTRY-SCRIPT: '{3}','{4}','{5}'
+__requires__ = '{3}'
+import re
+import sys
+
+from {0} import {1}
+
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
+    sys.exit({2}())
+""".lstrip()
+
+
+@classmethod
+def get_args(cls, dist, header=None):  # noqa: D205,D400
+    """
+    Yield write_script() argument tuples for a distribution's
+    console_scripts and gui_scripts entry points.
+    """
+    if header is None:
+        # pylint: disable=E1101
+        header = cls.get_header()
+    spec = str(dist.as_requirement())
+    for type_ in "console", "gui":
+        group = f'{type_}_scripts'
+        for name, ep in dist.get_entry_map(group).items():
+            # ensure_safe_name
+            if re.search(r"[\\/]", name):
+                raise ValueError("Path separators not allowed in script names")
+            script_text = TEMPLATE.format(
+                ep.module_name, ep.attrs[0], ".".join(ep.attrs), spec, group, name
+            )
+            # pylint: disable=E1101
+            args = cls._get_script_args(type_, name, header, script_text)
+            yield from args
+
+
+# pylint: disable=E1101
+easy_install.ScriptWriter.get_args = get_args
+
+
+def main():
+    import os
+    import shutil
+    import sys
+
+    dests = sys.argv[1:] or ["."]
+    filename = re.sub(r"\.pyc$", ".py", __file__)
+
+    for dst in dests:
+        shutil.copy(filename, dst)
+        manifest_path = os.path.join(dst, "MANIFEST.in")
+        setup_path = os.path.join(dst, "setup.py")
+
+        # Insert the include statement to MANIFEST.in if not present
+        with open(manifest_path, "a+") as manifest:
+            manifest.seek(0)
+            manifest_content = manifest.read()
+            if "include fastentrypoints.py" not in manifest_content:
+                manifest.write(
+                    ("\n" if manifest_content else "") + "include fastentrypoints.py"
+                )
+
+        # Insert the import statement to setup.py if not present
+        with open(setup_path, "a+") as setup:
+            setup.seek(0)
+            setup_content = setup.read()
+            if "import fastentrypoints" not in setup_content:
+                setup.seek(0)
+                setup.truncate()
+                setup.write("import fastentrypoints\n" + setup_content)

fprime_gds/common/encoders/seq_writer.py

@@ -137,9 +137,9 @@ class SeqBinaryWriter:
         for cmd in seq_cmds_list:
             sequence += self.__binaryCmdRecord(cmd)
         size = len(sequence)
-        tb_txt = b"ANY" if self.__timebase == 0xFFFF else bytes(self.__timebase)
+        tb_txt = "ANY" if self.__timebase == 0xFFFF else hex(self.__timebase)
 
-        print("Sequence is %d bytes with timebase %s" % (size, tb_txt))
+        print(f"Sequence is {size} bytes with timebase {tb_txt}")
 
         header = b""
         header += U32Type(

fprime_gds/common/files/uplinker.py

@@ -47,7 +47,9 @@ class UplinkQueue:
         self.queue = queue.Queue()
         self.__file_store = []
         self.__exit = threading.Event()
-        self.__thread = threading.Thread(target=self.run, name="UplinkerThread", args=())
+        self.__thread = threading.Thread(
+            target=self.run, name="UplinkerThread", args=()
+        )
         self.__thread.start()
 
     def enqueue(self, filepath, destination):
@@ -228,9 +230,7 @@ class FileUplinker(fprime_gds.common.handlers.DataHandler):
         # Prevent multiple uplinks at once
         if self.state != FileStates.IDLE:
             msg = f"Currently uplinking file '{self.active.source}' cannot start uplinking '{file_obj.source}'"
-            raise FileUplinkerBusyException(
-                msg
-            )
+            raise FileUplinkerBusyException(msg)
         self.state = FileStates.RUNNING
         self.active = file_obj
         self.active.open(TransmitFileState.READ)

fprime_gds/common/loaders/xml_loader.py

@@ -61,6 +61,7 @@ class XmlLoader(dict_loader.DictLoader):
     SER_MEMB_FMT_STR_TAG = "format_specifier"
     SER_MEMB_DESC_TAG = "description"
     SER_MEMB_TYPE_TAG = "type"
+    SER_MEMB_SIZE_TAG = "size"
 
     # Xml section names and tags for array types
     ARR_SECT = "arrays"
@@ -117,23 +118,6 @@ class XmlLoader(dict_loader.DictLoader):
             # Parse xml and get element tree object we can retrieve data from
             element_tree = etree.parse(fd, parser=xml_parser)
         root = element_tree.getroot()
-
-        # Check version of the XML before continuing. Versions weren't published before 1.5.4.  Only check major minor
-        # and point versions to allow for development versions to be allowed.
-        dict_version_string = root.attrib.get("framework_version", "1.5.4")
-        digits = []
-        # Process through the tokens of the version until we hit something that is not an int
-        for token in dict_version_string.split("."):
-            try:
-                digits.append(int(token))
-            except ValueError:
-                break
-        dict_version = tuple(digits)
-        if (
-            dict_version < MINIMUM_SUPPORTED_FRAMEWORK_VERSION
-            or dict_version > MAXIMUM_SUPPORTED_FRAMEWORK_VERSION
-        ):
-            raise UnsupportedDictionaryVersionException(dict_version)
         return root
 
     @staticmethod
@@ -273,7 +257,15 @@ class XmlLoader(dict_loader.DictLoader):
                     fmt_str = memb.get(self.SER_MEMB_FMT_STR_TAG)
                     desc = memb.get(self.SER_MEMB_DESC_TAG)
                     memb_type_name = memb.get(self.SER_MEMB_TYPE_TAG)
+                    memb_size = memb.get(self.SER_MEMB_SIZE_TAG)
                     type_obj = self.parse_type(memb_type_name, memb, xml_obj)
+                    # memb_size is not None for member array
+                    if(memb_size is not None):
+                        type_obj = ArrayType.construct_type(
+                            f"Array_{type_obj.__name__}_{memb_size}",
+                            type_obj,
+                            int(memb_size),
+                            fmt_str)
 
                     members.append((name, type_obj, fmt_str, desc))
 
@@ -401,22 +393,3 @@ class XmlLoader(dict_loader.DictLoader):
         raise exceptions.GseControllerParsingException(
             msg
         )
-
-
-class UnsupportedDictionaryVersionException(Exception):
-    """Dictionary is of unsupported version"""
-
-    def __init__(self, version):
-        """Create a dictionary of a specific version"""
-
-        def pretty(version_tuple):
-            """Pretty print version"""
-            return ".".join([str(item) for item in version_tuple])
-
-        super().__init__(
-            "Dictionary version {} is not in supported range: {}-{}. Please upgrade fprime-gds.".format(
-                pretty(version),
-                pretty(MINIMUM_SUPPORTED_FRAMEWORK_VERSION),
-                pretty(MAXIMUM_SUPPORTED_FRAMEWORK_VERSION),
-            )
-        )

fprime_gds/common/pipeline/files.py

@@ -7,7 +7,7 @@ communications layer.
 
 @author mstarch
 """
-import os
+from pathlib import Path
 import fprime_gds.common.files.downlinker
 import fprime_gds.common.files.uplinker
 
@@ -43,10 +43,11 @@ class Filing:
         )
         file_decoder.register(self.__downlinker)
         distributor.register("FW_PACKET_HAND", self.__uplinker)
-        if not os.access(down_store, os.W_OK):
+        try:
+            Path(down_store).mkdir(parents=True, exist_ok=True)
+        except PermissionError:
             raise PermissionError(
-                f"{down_store} is not writable. Downlinker not be able to save files. "
-                "Fix permissions or change storage directory with --file-storage-directory."
+                f"{down_store} is not writable. Fix permissions or change storage directory with --file-storage-directory."
             )
 
     @property

fprime_gds/common/pipeline/standard.py

@@ -44,6 +44,8 @@ class StandardPipeline:
         self.client_socket = None
         self.logger = None
         self.dictionary_path = None
+        self.up_store = None
+        self.down_store = None
 
         self.__dictionaries = dictionaries.Dictionaries()
         self.__coders = encoding.EncodingDecoding()
@@ -52,7 +54,7 @@ class StandardPipeline:
         self.__transport_type = ThreadedTCPSocketClient
 
     def setup(
-        self, config, dictionary, down_store, logging_prefix=None, packet_spec=None
+        self, config, dictionary, file_store, logging_prefix=None, packet_spec=None
     ):
         """
         Setup the standard pipeline for moving data from the middleware layer through the GDS layers using the standard
@@ -60,11 +62,23 @@ class StandardPipeline:
 
         :param config: config object used when constructing the pipeline.
         :param dictionary: dictionary path. Used to setup loading of dictionaries.
-        :param down_store: downlink storage directory
+        :param file_store: uplink/downlink storage directory
         :param logging_prefix: logging prefix. Defaults to not logging at all.
         :param packet_spec: location of packetized telemetry XML specification.
         """
-        assert dictionary is not None and Path(dictionary).is_file(), f"Dictionary {dictionary} does not exist"
+        assert (
+            dictionary is not None and Path(dictionary).is_file()
+        ), f"Dictionary {dictionary} does not exist"
+        # File storage configuration for uplink and downlink
+        self.up_store = Path(file_store) / "fprime-uplink"
+        self.down_store = Path(file_store) / "fprime-downlink"
+        try:
+            self.down_store.mkdir(parents=True, exist_ok=True)
+            self.up_store.mkdir(parents=True, exist_ok=True)
+        except PermissionError:
+            raise PermissionError(
+                f"{file_store} is not writable. Fix permissions or change storage directory with --file-storage-directory."
+            )
         self.dictionary_path = Path(dictionary)
         # Loads the distributor and client socket
         self.distributor = fprime_gds.common.distributor.distributor.Distributor(config)
@@ -76,7 +90,7 @@ class StandardPipeline:
         )
         self.histories.setup_histories(self.coders)
         self.files.setup_file_handling(
-            down_store,
+            self.down_store,
             self.coders.file_encoder,
             self.coders.file_decoder,
             self.distributor,
@@ -152,7 +166,11 @@ class StandardPipeline:
             outgoing_tag: this pipeline will produce data for supplied tag (FSW, GUI). Default: FSW
         """
         # Backwards compatibility with the old method .connect(host, port)
-        if isinstance(incoming_tag, int) and ":" not in connection_uri and outgoing_tag == RoutingTag.FSW:
+        if (
+            isinstance(incoming_tag, int)
+            and ":" not in connection_uri
+            and outgoing_tag == RoutingTag.FSW
+        ):
             connection_uri = f"{connection_uri}:{incoming_tag}"
             incoming_tag = RoutingTag.GUI
         self.client_socket.connect(connection_uri, incoming_tag, outgoing_tag)

fprime_gds/common/testing_fw/api.py

@@ -402,7 +402,7 @@ class IntegrationTestAPI(DataHandler):
             return self.await_event_sequence(events, start=start, timeout=timeout)
         return self.await_event(events, start=start, timeout=timeout)
 
-    def send_and_assert_command(self, command, args=[], max_delay=None, timeout=5, events=None):
+    def send_and_assert_command(self, command, args=[], max_delay=None, timeout=5, events=None, commander="cmdDisp"):
         """
         This helper will send a command and verify that the command was dispatched and completed
         within the F' deployment. This helper can retroactively check that the delay between
@@ -414,12 +414,13 @@ class IntegrationTestAPI(DataHandler):
             max_delay: the maximum allowable delay between dispatch and completion (int/float)
             timeout: the number of seconds to wait before terminating the search (int)
             events: extra event predicates to check between  dispatch and complete
+            commander: the command dispatching component. Defaults to cmdDisp
         Return:
             returns a list of the EventData objects found by the search
         """
         cmd_id = self.translate_command_name(command)
-        dispatch = [self.get_event_pred("cmdDisp.OpCodeDispatched", [cmd_id, None])]
-        complete = [self.get_event_pred("cmdDisp.OpCodeCompleted", [cmd_id])]
+        dispatch = [self.get_event_pred(f"{commander}.OpCodeDispatched", [cmd_id, None])]
+        complete = [self.get_event_pred(f"{commander}.OpCodeCompleted", [cmd_id])]
         events = dispatch + (events if events else []) + complete
         results = self.send_and_assert_event(command, args, events, timeout=timeout)
         if max_delay is not None:

fprime_gds/executables/cli.py

@@ -547,18 +547,31 @@ class FileHandlingParser(ParserBase):
 
         return {
             ("--file-storage-directory",): {
-                "dest": "files_directory",
+                "dest": "files_storage_directory",
                 "action": "store",
-                "default": "/tmp/" + username + "/fprime-downlink/",
+                "default": "/tmp/" + username,
                 "required": False,
                 "type": str,
-                "help": "File to store uplink and downlink files. Default: %(default)s",
-            }
+                "help": "Directory to store uplink and downlink files. Default: %(default)s",
+            },
+            ("--remote-sequence-directory",): {
+                "dest": "remote_sequence_directory",
+                "action": "store",
+                "default": "/seq",
+                "required": False,
+                "type": str,
+                "help": "Directory to save command sequence binaries, on the remote FSW. Default: %(default)s",
+            },
         }
 
     def handle_arguments(self, args, **kwargs):
         """Handle arguments as parsed"""
-        os.makedirs(args.files_directory, exist_ok=True)
+        try:
+            Path(args.files_storage_directory).mkdir(parents=True, exist_ok=True)
+        except PermissionError:
+            raise PermissionError(
+                f"{args.files_storage_directory} is not writable. Fix permissions or change storage directory with --file-storage-directory."
+            )
         return args
 
 
@@ -584,7 +597,7 @@ class StandardPipelineParser(CompositeParser):
         pipeline_arguments = {
             "config": ConfigManager(),
             "dictionary": args_ns.dictionary,
-            "down_store": args_ns.files_directory,
+            "file_store": args_ns.files_storage_directory,
             "packet_spec": args_ns.packet_spec,
             "logging_prefix": args_ns.logs,
         }

fprime_gds/executables/comm.py

@@ -64,7 +64,7 @@ def main():
     )
     fprime_gds.common.communication.checksum = args.checksum_type
     if args.comm_adapter == "none":
-        print("[ERROR] Comm adapter set to 'none'. Nothing to do but exit.")
+        print("[ERROR] Comm adapter set to 'none'. Nothing to do but exit.", file=sys.stderr)
         sys.exit(-1)
 
     # Create the handling components for either side of this script, adapter for hardware, and ground for the GDS side

fprime_gds/executables/run_deployment.py

@@ -168,7 +168,7 @@ def main():
         if parsed_args.adapter == "ip":
             launchers.append(launch_app)
         else:
-            print("[WARNING] App cannot be auto-launched without IP adapter")
+            print("[WARNING] App cannot be auto-launched without IP adapter", file=sys.stderr)
 
     # Launch the desired GUI package
     if parsed_args.gui == "html":

fprime_gds/executables/utils.py

@@ -146,11 +146,12 @@ def get_artifacts_root() -> Path:
         ini_settings = IniSettings.load(ini_file)
     except FprimeLocationUnknownException:
         print(
-            "[ERROR] Not in fprime project and no deployment path provided, unable to find dictionary and/or app"
+            "[ERROR] Not in fprime project and no deployment path provided, unable to find dictionary and/or app",
+            file=sys.stderr
         )
         sys.exit(-1)
     except FprimeSettingsException as e:
-        print("[ERROR]", e)
+        print("[ERROR]", e, file=sys.stderr)
         sys.exit(-1)
     assert (
         "install_destination" in ini_settings
@@ -165,17 +166,18 @@ def find_app(root: Path) -> Path:
     bin_dir = root / "bin"
 
     if not bin_dir.exists():
-        print(f"[ERROR] binary location {bin_dir} does not exist")
+        print(f"[ERROR] binary location {bin_dir} does not exist", file=sys.stderr)
         sys.exit(-1)
 
     files = [child for child in bin_dir.iterdir() if child.is_file()]
     if not files:
-        print(f"[ERROR] App not found in {bin_dir}")
+        print(f"[ERROR] App not found in {bin_dir}", file=sys.stderr)
         sys.exit(-1)
 
     if len(files) > 1:
         print(
-            f"[ERROR] Multiple app candidates in binary location {bin_dir}. Specify app manually with --app."
+            f"[ERROR] Multiple app candidates in binary location {bin_dir}. Specify app manually with --app.",
+            file=sys.stderr
         )
         sys.exit(-1)
 
@@ -186,7 +188,7 @@ def find_dict(root: Path) -> Path:
     dict_dir = root / "dict"
 
     if not dict_dir.exists():
-        print(f"[ERROR] dictionary location {dict_dir} does not exist")
+        print(f"[ERROR] dictionary location {dict_dir} does not exist", file=sys.stderr)
         sys.exit(-1)
 
     files = [
@@ -196,12 +198,13 @@ def find_dict(root: Path) -> Path:
     ]
 
     if not files:
-        print(f"[ERROR] No xml dictionary found in dictionary location {dict_dir}")
+        print(f"[ERROR] No xml dictionary found in dictionary location {dict_dir}", file=sys.stderr)
         sys.exit(-1)
 
     if len(files) > 1:
         print(
-            f"[ERROR] Multiple xml dictionaries found in dictionary location {dict_dir}. Specify dictionary manually with --dictionary."
+            f"[ERROR] Multiple xml dictionaries found in dictionary location {dict_dir}. Specify dictionary manually with --dictionary.",
+            file=sys.stderr
         )
         sys.exit(-1)
 

fprime_gds/flask/app.py

@@ -30,7 +30,6 @@ import fprime_gds.flask.sequence
 import fprime_gds.flask.stats
 import fprime_gds.flask.updown
 from fprime_gds.executables.cli import ParserBase, StandardPipelineParser
-from fprime_gds.flask import flask_uploads
 
 from . import components
 
@@ -49,8 +48,7 @@ def construct_app():
     2. Setup JSON encoding for Flask and flask_restful to handle F prime types natively
     3. Setup standard pipeline used throughout the system
     4. Create Restful API for registering flask items
-    5. Setup flask_uploads settings
-    6. Register all restful endpoints
+    5. Register all restful endpoints
 
     :return: setup app
     """
@@ -77,9 +75,6 @@ def construct_app():
 
     # Restful API registration
     api = fprime_gds.flask.errors.setup_error_handling(app)
-    # File upload configuration, 1 set for everything
-    uplink_set = flask_uploads.UploadSet("uplink", flask_uploads.ALL)
-    flask_uploads.configure_uploads(app, [uplink_set])
 
     # Application routes
     api.add_resource(
@@ -137,7 +132,7 @@ def construct_app():
     api.add_resource(
         fprime_gds.flask.updown.FileUploads,
         "/upload/files",
-        resource_class_args=[pipeline.files.uplinker, uplink_set],
+        resource_class_args=[pipeline.files.uplinker, pipeline.up_store],
     )
     api.add_resource(
         fprime_gds.flask.updown.FileDownload,
@@ -150,9 +145,9 @@ def construct_app():
         "/sequence",
         resource_class_args=[
             args_ns.dictionary,
-            app.config["UPLOADED_UPLINK_DEST"],
+            pipeline.up_store,
             pipeline.files.uplinker,
-            app.config["REMOTE_SEQ_DIRECTORY"],
+            args_ns.remote_sequence_directory,
         ],
     )
     api.add_resource(

fprime_gds/flask/default_settings.py

@@ -9,23 +9,12 @@
 #
 ####
 import os
-import getpass
-
-# Select uploads directory and create it
-username = getpass.getuser()
-uplink_dir = os.environ.get("UP_FILES_DIR", "/tmp/" + username + "/fprime-uplink/")
-DOWNLINK_DIR = os.environ.get("DOWN_FILES_DIR", "/tmp/" + username + "/fprime-downlink/")
 
 STANDARD_PIPELINE_ARGUMENTS = os.environ.get("STANDARD_PIPELINE_ARGUMENTS").split("|")
 
 SERVE_LOGS = os.environ.get("SERVE_LOGS", "YES") == "YES"
-UPLOADED_UPLINK_DEST = uplink_dir
-UPLOADS_DEFAULT_DEST = uplink_dir
-REMOTE_SEQ_DIRECTORY = "/seq"
-MAX_CONTENT_LENGTH = 32 * 1024 * 1024  # Max length of request is 32MiB
 
+MAX_CONTENT_LENGTH = 32 * 1024 * 1024  # Max length of request is 32MiB
 
-for directory in [UPLOADED_UPLINK_DEST, UPLOADS_DEFAULT_DEST, DOWNLINK_DIR]:
-    os.makedirs(directory, exist_ok=True)
 
 # TODO: load real config

fprime_gds/flask/static/addons/commanding/command-history.js

@@ -102,8 +102,29 @@ Vue.component("command-history", {
             cmd.full_name = template.full_name;
             // Can only set command if it is a child of a command input
             if (this.$parent.selectCmd) {
-                this.$parent.selectCmd(cmd.full_name, cmd.args);
+                // command-input expects an array of strings as arguments
+                this.$parent.selectCmd(cmd.full_name, this.preprocess_args(cmd.args));
+            }
+        },
+        /**
+         * Process the arguments for a command. If the argument is (or contains) a number, it
+         * is converted to a string. Other types that should be pre-processed can be added here.
+         * 
+         * @param {*} args 
+         * @returns args processed for command input (numbers converted to strings)
+         */
+        preprocess_args(args) {
+            if (Array.isArray(args)) {
+                return args.map(el => this.preprocess_args(el));
+            } else if (typeof args === 'object' && args !== null) {
+                return Object.fromEntries(
+                    Object.entries(args).map(([key, value]) => [key, this.preprocess_args(value)])
+                );
+            } else if (typeof args === 'number') {
+                return args.toString();
+            } else {
+                return args;
             }
         }
     }
-});
+});

fprime_gds/flask/updown.py

@@ -11,6 +11,9 @@ import os
 
 import flask
 import flask_restful
+from werkzeug.datastructures import FileStorage
+from werkzeug.utils import secure_filename
+from pathlib import Path
 
 
 class Destination(flask_restful.Resource):
@@ -51,12 +54,12 @@ class FileUploads(flask_restful.Resource):
     A data model for the current uplinking file set.
     """
 
-    def __init__(self, uplinker, uplink_set):
+    def __init__(self, uplinker, dest_dir):
         """
         Constructor: setup the uplinker and argument parsing
         """
         self.uplinker = uplinker
-        self.uplink_set = uplink_set
+        self.dest_dir = dest_dir
         self.parser = flask_restful.reqparse.RequestParser()
         self.parser.add_argument(
             "action", required=True, help="Action to take against files"
@@ -99,11 +102,9 @@ class FileUploads(flask_restful.Resource):
         failed = []
         for key, file in flask.request.files.items():
             try:
-                filename = self.uplink_set.save(file)
+                filename = self.save(file)
                 flask.current_app.logger.info(f"Received file. Saved to: {filename}")
-                self.uplinker.enqueue(
-                    os.path.join(self.uplink_set.config.destination, filename)
-                )
+                self.uplinker.enqueue(os.path.join(self.dest_dir, filename))
                 successful.append(key)
             except Exception as exc:
                 flask.current_app.logger.warning(
@@ -112,6 +113,56 @@ class FileUploads(flask_restful.Resource):
                 failed.append(key)
         return {"successful": successful, "failed": failed}
 
+    def save(self, file_storage: FileStorage):
+        """
+        This saves a `werkzeug.FileStorage` into this upload set.
+
+        :param file_storage: The uploaded file to save.
+        """
+        if not isinstance(file_storage, FileStorage):
+            raise TypeError("file_storage must be a werkzeug.FileStorage")
+
+        filename = Path(secure_filename(file_storage.filename)).name
+        dest_dir = Path(self.dest_dir)
+
+        try:
+            dest_dir.mkdir(parents=True, exist_ok=True)
+        except PermissionError:
+            raise PermissionError(
+                f"{dest_dir} is not writable. Fix permissions or change storage directory with --file-storage-directory."
+            )
+
+        # resolve conflict may not be needed
+        if (dest_dir / filename).exists():
+            filename = self.resolve_conflict(dest_dir, filename)
+
+        target = dest_dir / filename
+        file_storage.save(str(target))
+
+        return filename
+
+    def resolve_conflict(self, target_folder: Path, filename: str):
+        """
+        If a file with the selected name already exists in the target folder,
+        this method is called to resolve the conflict. It should return a new
+        filename for the file.
+
+        The default implementation splits the name and extension and adds a
+        suffix to the name consisting of an underscore and a number, and tries
+        that until it finds one that doesn't exist.
+
+        :param target_folder: The absolute path to the target.
+        :param filename: The file's original filename.
+        """
+        path = Path(filename)
+        name, ext = path.stem, path.suffix
+        count = 0
+        while True:
+            count = count + 1
+            newname = f"{name}_{count}{ext}"
+            if not (Path(target_folder) / newname).exists():
+                return newname
+
 
 class FileDownload(flask_restful.Resource):
     """ """