Versions Compared


  • This line was added.
  • This line was removed.
  • Formatting was changed.


  1. Off-line Batch Processing Service:

    1. In order to run a task/SuperTask, the Batch Processing Service's compute job must set up input files, previously transferred to an empty local disk via some non-Butler mechanism, in a way accessible by the Butler being used by the task/SuperTask.    (Currently the initial execution would be of the command-line task/activator).

    2. The execution of a SuperTask inside a pipeline during operations wants an input file that doesn't exist in the local repository.     This should be a failure (as opposed to helpfully fetching the file for the supertask).   

    3. The Batch Processing Service will transfer the output files out of the job scratch disk to either other working areas or back to Data Backbone (where the filename must be unique).

      1. When we do production runs, yes the Butler could name the files whatever, and then we have to wrap every execution with a wrapper (executor) to rename the files appropriately.     This obscures things on many levels (workflow system thinks it is only running 1 executable, digging around a filesystem while debugging an active job means different filenames), and we strongly prefer not to do so.

      2. This does NOT mean that Butler itself has to be able to generate unique filenames.    If it allows the user of the Butler (i.e., production framework) to tell it how to name output files (like it currently does but needs to be easier), this would be good enough for Operations.

    4. Operators need to be able to easily override defaults for inputs.   ExamplesThe operator wants to execute a pipeline via the Batch Processing Service using a different calibration than as used previously. They edit some configuration changing the calibration lookup strategy and submit the processing attempt.   Examples:

      1. Use different set of calibration files

      2. The Operations consolidated DB will have many files/data which should not be used as inputs for a particular execution.    Need an easy way to do this.

    5. Many data management tasks will need consolidated database access.     It is not clear what is to be gained by going through the Butler.    Most of these would never be used by anyone other than a few Operations staff.   If should be using Butler, many more use cases would come here.

      1. A file registration function/program (initiated via operator, batch processing service, raw file delivery, etc) will insert data about specific files into the database:  file catalog, file metadata, provenance

      2. A data management program will check file information stored in a database vs actual physical file information to ensure DB correctness as well as finding bit-rot.

      3. An operator or data management tool needs to query any table in the DB  (Yes this could/should be broken up into exact use cases.    If needed I could start listing them individually.) 

      4. An operator will need to delete DB rows from bad or test runs that are not needed for historical provenance, e.g. objects.

    6. Data ingestion codes need to insert non-file metadata science information into the consolidated DB:   qc values, objects from catalogs, etc.

      1. Note:   Ingesting large number of objects in Operations will need a different manner of insertion than say a single row of metadata.   

    7. A file registration function/program needs to read metadata from a file to save in the Data Backbone (needs to have ability to be different/more than is needed for internal Butler use)

      1. Should not have to have to do anything other than call function that reads the file.     Does not seem to be a Butler use case, but more for the afwImage level.

      2. At least in the Operations schema, will probably want to save metadata also for intermediate files (files generated during pipeline execution, but not brought back to Data Backbone)

    8. The Batch Processing Service needs to gathering file provenance for inputs/outputs of a running pipeline (this file was used by what process and the process generated what file).

      1. At least in the Operations schema, we will probably want to save file provenance also for intermediate files

      2. Is this a use case for Butler?

        1. Butler could report what objects(?) have been accessed via get/put.

        2. The above should exactly match the pre-flight information for production executions.

          1. Can’t access files not staged to job scratch

          2. Processing will be aborted if expected output files are not created

          3. Extra output files may either be left behind or bundled in a junk file tarball and can’t be used in downstream processing (especially true if not in same compute job)

          4. So, the case of interest is whether the pre-flight said to use X files, but the code eliminated an input based upon science reasons after opening the file.

        3. If a code eliminate a given input after reading it, Butler won’t be able to tell.    Would be better if code that can eliminate an input explicitly tells what it did use.

        4. Operations would prefer to have Butler report actual filenames used:

          1. Filenames are what will be used in saving provenance

          2. Helps illuminate problems/different expectations from translating data Ids to files on disk.

    9. The Batch Processing Service wants to save execution provenance (times, execution host, software stack, memory usage, etc).    Other than it being a DB insertion/update, does not seem to be a Butler use case.

    10. The Batch Processing Service wants to save log file contents to something like LogStash.   (Doesn’t sound like Butler use case)

  2. Debugging processing issues:

    1. Operations staff member (e.g., Robert Gruendl) manually gets/creates input files of interest.    He wants to easily run a couple pipeline steps on their own workstation or LSST development cluster.    He needs to easily set up the environment in order to be able to run.    (e.g., Do files need to be in specific folder structures? (Currently yes))

    2. Operations staff member (e.g., Robert Gruendl) needs to run queries against operational DB to perform quality checks across data.    Must be flexible.  Able to write/try various queries that could be complicated, use global temp tables, etc.   Not clear that folks would not be using regular DB clients like sqlplus or in the case of a python program whether it needs to go through the Butler.

    3. Operations staff member (e.g., Michelle Gower) needs to run queries against operational DB to check for non-science issues such as “bad” machine, dramatic increase in run times, failures, etc. Not clear that folks would not be using regular DB clients like sqlplus or in the case of a python program whether it needs to go through the Butler.

  3. L1 Enclave

    1. Raw files will be written to a FIFO filesystem in Observatory Operational System (OOS) by (Jim’s) forwarder for use by folks at the base.   Observatory Operations Staff needs to use these files via SuperTasks and other tools (an observatory portal?)   

      1. The contents on disk changes as fast as the camera can cycle.    This filesystem will be (NFS) mounted read only on commissioning cluster.    

    2. Observatory Operations staff member needs to extract a non-raw file (e.g., calibration) from the data backbone and store it on their human-managed filesystem in a manner that is usable by SuperTasks.

    3. Observatory Operations staff member needs to delete a file from their human-managed filesystem in a manner that corrects information used by SuperTasks.

  4. Data Backbone (not directly involved with processing):

    1. A raw file ingestion service will ingest raw files into the data backbone (base comes later than NCSA)

      1. Includes transfer of files + saving data into file catalog, metadata tables, and provenance tables (provenance means introduced to data backbone via Raw file path, not what processes were done to it at the base prior to this).

    2. An Operator needs to manually ingest into the data backbone files created externally to the camera or Batch Processing Service to be used by pipelines

      1. Includes (probably manual) renaming of files to unique names, moving files into place, saving data into file catalog, metadata tables, and provenance tables (provenance means an externally created file was introduced to the system.   NOT saving whatever provenance external process was done.)

  5. Alert Prompt Processing (Temp placeholders until Felipe can chime in.   Many are directly Alert Prompt Processing pipeline related.)

    1. Generically, this is all decoupled from the data backbone, consolidated DB and alert distribution system to allow it to continue processing despite outages in those other systems.   At some independent cadence, information/files flow between them.

    2. Forwarders deliver the crosstalked-corrected files to NCSA distributors which will make these files visible on the Prompt Processing cluster.

    3. A separate setup process (name TBD) will populate Prompt Processing filesystems with input files needed for the night's processing.

    4. Alert Prompt Processing pipeline will read template files from a template filesystem.        

    5. Alert Prompt Processing pipeline will write its output files to an output filesystem.

    6. Alert Prompt Processing pipeline will read from and write to a separate real-time AP database.

    7. Alert Prompt Processing pipeline will feed back image information like psf, wcs, etc back to the telemetry gateway service on the NCSA foreman which sends information back to the base.  (If the feedback is via a file, then normal Butler use case.    If the feedback is via direct messaging with the service, then not clear this is a Butler use case.)

    8. A separate post process (name TBD) will copy output data from the L1 enclave into the Operations database and filesystem.

  6. An EFD ETL process will extract from the base EFD, translate the data and load tables in NCSA consolidated database.

    1. Will be working with databases, but this process shouldn’t have to use the Butler.

  7. The database admin will initiate a data release process which extracts, translates, and loads the data from the operations database into the release database.

    1. Mostly database work transforming data from the operational consolidated database to a release consolidated database. (Probably not a Butler use case as these are normally specialized/optimized )

    2. Loading Qserv (again expecting not really a Butler use case if database to database, but if done on a file basis closer to the actual production then could be if the Qserv folks want to do so)

  8. Disaster Recovery/Backup services will save data to other locations or tape. - not a Butler use case

  9. The Data Backbone will store files on tape and must retrieve them for use by Batch Production Service (not a Butler use case for production uses)

    1. Certain files will need to be stored on tape in certain matter for efficient retrieval

    2. May be managed by 3rd party software (like Rucio)

    3. Not clear how much end-users would be accessing files on tape.  (if allowed, may be Butler use case).

  10. The Data Backbone will deliver files to LSST DAC Chile (not a Butler use case)

  11. Delivering files between NCSA and IN2P3 (not a Butler use case)

    1. The Data Backbone will deliver raw files from NCSA to IN2P3

    2. The Batch Processing Service will deliver other inputs for processing from NCSA to IN2P3

    3. The Batch Processing Service will deliver outputs from processing at IN2P3 to NCSA

    4. The Data Backbone will deliver release files from NCSA to IN2P3 (backup, IN2P3 DAC)

  12. Bulk file delivery service/program will bulk copy files between NCSA and a non-LSST DAC  (i.e., not Chile, NCSA, or IN2P3).    Not a Butler use case.