├── .formatter.exs
├── .gitignore
├── CHANGELOG.md
├── LICENSE
├── README.md
├── assets
    ├── package-lock.json
    ├── package.json
    ├── src
    │   ├── index.js
    │   └── scss
    │   │   ├── button.scss
    │   │   ├── chore-item.scss
    │   │   ├── colors.scss
    │   │   ├── container.scss
    │   │   ├── downloads.scss
    │   │   ├── form.scss
    │   │   ├── index.scss
    │   │   ├── modal.scss
    │   │   ├── typography.scss
    │   │   └── variables.scss
    └── webpack.config.js
├── lib
    ├── chore_runner.ex
    ├── chore_runner
    │   ├── chore.ex
    │   ├── chore_case.ex
    │   ├── chore_case
    │   │   └── test_reporter.ex
    │   ├── downloads.ex
    │   ├── downloads
    │   │   ├── storage_service.ex
    │   │   └── temporary_disk_storage_service.ex
    │   ├── dsl.ex
    │   ├── input.ex
    │   ├── reporter.ex
    │   ├── reporter_supervisor.ex
    │   └── supervisor.ex
    ├── chore_runner_ui.ex
    ├── chore_runner_ui
    │   ├── chore_live.ex
    │   ├── chore_view.ex
    │   ├── components
    │   │   ├── chore_item_components.ex
    │   │   └── chore_modal_component.ex
    │   ├── downloads_live.ex
    │   ├── downloads_live.html.heex
    │   ├── downloads_plug.ex
    │   └── templates
    │   │   └── chore
    │   │       ├── chore_input_errors.html.leex
    │   │       ├── chore_inputs.html.heex
    │   │       ├── chore_item.html.heex
    │   │       ├── index.html.heex
    │   │       └── live.html.leex
    └── example.ex
├── mix.exs
├── mix.lock
├── priv
    └── css
    │   ├── chore.css
    │   └── main.css
└── test
    ├── chore_test.exs
    ├── support
        ├── test_chore.ex
        └── test_file.txt
    └── test_helper.exs


/.formatter.exs:
--------------------------------------------------------------------------------
 1 | # Used by "mix format"
 2 | locals_without_parens = [
 3 |   input: 2
 4 | ]
 5 | 
 6 | [
 7 |   inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}"],
 8 |   locals_without_parens: locals_without_parens,
 9 |   export: [
10 |     locals_without_parens: locals_without_parens
11 |   ]
12 | ]
13 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # The directory Mix will write compiled artifacts to.
 2 | /_build/
 3 | 
 4 | # If you run "mix test --cover", coverage assets end up here.
 5 | /cover/
 6 | 
 7 | # The directory Mix downloads your dependencies sources to.
 8 | /deps/
 9 | 
10 | # Where third-party dependencies like ExDoc output generated docs.
11 | /doc/
12 | 
13 | # Ignore .fetch files in case you like to edit your project deps locally.
14 | /.fetch
15 | 
16 | # If the VM crashes, it generates a dump, let's ignore it too.
17 | erl_crash.dump
18 | 
19 | # Also ignore archive artifacts (built via "mix archive.build").
20 | *.ez
21 | 
22 | # Ignore package tarball (built via "mix hex.build").
23 | chore-*.tar
24 | 
25 | # Temporary files, for example, from tests.
26 | /tmp/
27 | 
28 | node_modules
29 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
1 | # Changelog
2 | 
3 | ## v0.2.0 (2022-08-12)
4 | 
5 | ### Breaking Change
6 | 
7 | * Added "Live Navigation" and dropped support for `live_render/3` based integration 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 | Apache License
  2 | Version 2.0, January 2004
  3 | http://www.apache.org/licenses/
  4 | 
  5 | TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  6 | 
  7 | 1. Definitions.
  8 | 
  9 | "License" shall mean the terms and conditions for use, reproduction,
 10 | and distribution as defined by Sections 1 through 9 of this document.
 11 | 
 12 | "Licensor" shall mean the copyright owner or entity authorized by
 13 | the copyright owner that is granting the License.
 14 | 
 15 | "Legal Entity" shall mean the union of the acting entity and all
 16 | other entities that control, are controlled by, or are under common
 17 | control with that entity. For the purposes of this definition,
 18 | "control" means (i) the power_control, direct or indirect, to cause the
 19 | direction or management of such entity, whether by contract or
 20 | otherwise, or (ii) ownership of fifty percent (50%) or more of the
 21 | outstanding shares, or (iii) beneficial ownership of such entity.
 22 | 
 23 | "You" (or "Your") shall mean an individual or Legal Entity
 24 | exercising permissions granted by this License.
 25 | 
 26 | "Source" form shall mean the preferred form for making modifications,
 27 | including but not limited to software source code, documentation
 28 | source, and configuration files.
 29 | 
 30 | "Object" form shall mean any form resulting from mechanical
 31 | transformation or translation of a Source form, including but
 32 | not limited to compiled object code, generated documentation,
 33 | and conversions to other media types.
 34 | 
 35 | "Work" shall mean the work of authorship, whether in Source or
 36 | Object form, made available under the License, as indicated by a
 37 | copyright notice that is included in or attached to the work
 38 | (an example is provided in the Appendix below).
 39 | 
 40 | "Derivative Works" shall mean any work, whether in Source or Object
 41 | form, that is based on (or derived from) the Work and for which the
 42 | editorial revisions, annotations, elaborations, or other modifications
 43 | represent, as a whole, an original work of authorship. For the purposes
 44 | of this License, Derivative Works shall not include works that remain
 45 | separable from, or merely link (or bind by name) to the interfaces of,
 46 | the Work and Derivative Works thereof.
 47 | 
 48 | "Contribution" shall mean any work of authorship, including
 49 | the original version of the Work and any modifications or additions
 50 | to that Work or Derivative Works thereof, that is intentionally
 51 | submitted to Licensor for inclusion in the Work by the copyright owner
 52 | or by an individual or Legal Entity authorized to submit on behalf of
 53 | the copyright owner. For the purposes of this definition, "submitted"
 54 | means any form of electronic, verbal, or written communication sent
 55 | to the Licensor or its representatives, including but not limited to
 56 | communication on electronic mailing lists, source code control systems,
 57 | and issue tracking systems that are managed by, or on behalf of, the
 58 | Licensor for the purpose of discussing and improving the Work, but
 59 | excluding communication that is conspicuously marked or otherwise
 60 | designated in writing by the copyright owner as "Not a Contribution."
 61 | 
 62 | "Contributor" shall mean Licensor and any individual or Legal Entity
 63 | on behalf of whom a Contribution has been received by Licensor and
 64 | subsequently incorporated within the Work.
 65 | 
 66 | 2. Grant of Copyright License. Subject to the terms and conditions of
 67 | this License, each Contributor hereby grants to You a perpetual,
 68 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 69 | copyright license to reproduce, prepare Derivative Works of,
 70 | publicly display, publicly perform, sublicense, and distribute the
 71 | Work and such Derivative Works in Source or Object form.
 72 | 
 73 | 3. Grant of Patent License. Subject to the terms and conditions of
 74 | this License, each Contributor hereby grants to You a perpetual,
 75 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 76 | (except as stated in this section) patent license to make, have made,
 77 | use, offer to sell, sell, import, and otherwise transfer the Work,
 78 | where such license applies only to those patent claims licensable
 79 | by such Contributor that are necessarily infringed by their
 80 | Contribution(s) alone or by combination of their Contribution(s)
 81 | with the Work to which such Contribution(s) was submitted. If You
 82 | institute patent litigation against any entity (including a
 83 | cross-claim or counterclaim in a lawsuit) alleging that the Work
 84 | or a Contribution incorporated within the Work constitutes direct
 85 | or contributory patent infringement, then any patent licenses
 86 | granted to You under this License for that Work shall terminate
 87 | as of the date such litigation is filed.
 88 | 
 89 | 4. Redistribution. You may reproduce and distribute copies of the
 90 | Work or Derivative Works thereof in any medium, with or without
 91 | modifications, and in Source or Object form, provided that You
 92 | meet the following conditions:
 93 | 
 94 | (a) You must give any other recipients of the Work or
 95 | Derivative Works a copy of this License; and
 96 | 
 97 | (b) You must cause any modified files to carry prominent notices
 98 | stating that You changed the files; and
 99 | 
100 | (c) You must retain, in the Source form of any Derivative Works
101 | that You distribute, all copyright, patent, trademark, and
102 | attribution notices from the Source form of the Work,
103 | excluding those notices that do not pertain to any part of
104 | the Derivative Works; and
105 | 
106 | (d) If the Work includes a "NOTICE" text file as part of its
107 | distribution, then any Derivative Works that You distribute must
108 | include a readable copy of the attribution notices contained
109 | within such NOTICE file, excluding those notices that do not
110 | pertain to any part of the Derivative Works, in at least one
111 | of the following places: within a NOTICE text file distributed
112 | as part of the Derivative Works; within the Source form or
113 | documentation, if provided along with the Derivative Works; or,
114 | within a display generated by the Derivative Works, if and
115 | wherever such third-party notices normally appear. The contents
116 | of the NOTICE file are for informational purposes only and
117 | do not modify the License. You may add Your own attribution
118 | notices within Derivative Works that You distribute, alongside
119 | or as an addendum to the NOTICE text from the Work, provided
120 | that such additional attribution notices cannot be construed
121 | as modifying the License.
122 | 
123 | You may add Your own copyright statement to Your modifications and
124 | may provide additional or different license terms and conditions
125 | for use, reproduction, or distribution of Your modifications, or
126 | for any such Derivative Works as a whole, provided Your use,
127 | reproduction, and distribution of the Work otherwise complies with
128 | the conditions stated in this License.
129 | 
130 | 5. Submission of Contributions. Unless You explicitly state otherwise,
131 | any Contribution intentionally submitted for inclusion in the Work
132 | by You to the Licensor shall be under the terms and conditions of
133 | this License, without any additional terms or conditions.
134 | Notwithstanding the above, nothing herein shall supersede or modify
135 | the terms of any separate license agreement you may have executed
136 | with Licensor regarding such Contributions.
137 | 
138 | 6. Trademarks. This License does not grant permission to use the trade
139 | names, trademarks, service marks, or product names of the Licensor,
140 | except as required for reasonable and customary use in describing the
141 | origin of the Work and reproducing the content of the NOTICE file.
142 | 
143 | 7. Disclaimer of Warranty. Unless required by applicable law or
144 | agreed to in writing, Licensor provides the Work (and each
145 | Contributor provides its Contributions) on an "AS IS" BASIS,
146 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147 | implied, including, without limitation, any warranties or conditions
148 | of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149 | PARTICULAR PURPOSE. You are solely responsible for determining the
150 | appropriateness of using or redistributing the Work and assume any
151 | risks associated with Your exercise of permissions under this License.
152 | 
153 | 8. Limitation of Liability. In no event and under no legal theory,
154 | whether in tort (including negligence), contract, or otherwise,
155 | unless required by applicable law (such as deliberate and grossly
156 | negligent acts) or agreed to in writing, shall any Contributor be
157 | liable to You for damages, including any direct, indirect, special,
158 | incidental, or consequential damages of any character arising as a
159 | result of this License or out of the use or inability to use the
160 | Work (including but not limited to damages for loss of goodwill,
161 | work stoppage, computer failure or malfunction, or any and all
162 | other commercial damages or losses), even if such Contributor
163 | has been advised of the possibility of such damages.
164 | 
165 | 9. Accepting Warranty or Additional Liability. While redistributing
166 | the Work or Derivative Works thereof, You may choose to offer,
167 | and charge a fee for, acceptance of support, warranty, indemnity,
168 | or other liability obligations and/or rights consistent with this
169 | License. However, in accepting such obligations, You may act only
170 | on Your own behalf and on Your sole responsibility, not on behalf
171 | of any other Contributor, and only if You agree to indemnify,
172 | defend, and hold each Contributor harmless for any liability
173 | incurred by, or claims asserted against, such Contributor by reason
174 | of your accepting any such warranty or additional liability.
175 | 
176 | END OF TERMS AND CONDITIONS
177 | 
178 | APPENDIX: How to apply the Apache License to your work.
179 | 
180 | To apply the Apache License to your work, attach the following
181 | boilerplate notice, with the fields enclosed by brackets "{}"
182 | replaced with your own identifying information. (Don't include
183 | the brackets!)  The text should be enclosed in the appropriate
184 | comment syntax for the file format. We also recommend that a
185 | file or class name and description of purpose be included on the
186 | same "printed page" as the copyright notice for easier
187 | identification within third-party archives.
188 | 
189 | Copyright 2021 PepsiCo
190 | 
191 | Licensed under the Apache License, Version 2.0 (the "License");
192 | you may not use this file except in compliance with the License.
193 | You may obtain a copy of the License at
194 | 
195 | http://www.apache.org/licenses/LICENSE-2.0
196 | 
197 | Unless required by applicable law or agreed to in writing, software
198 | distributed under the License is distributed on an "AS IS" BASIS,
199 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
200 | See the License for the specific language governing permissions and
201 | limitations under the License.
202 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # ChoreRunner
  2 | An Elixir library for writing and running code chores.
  3 | 
  4 | - [Motivation](#motivation)
  5 | - [Installation](#installation)
  6 | - [Writing a Chore](#writing-a-chore)
  7 | - [Chore Reporting](#chore-reporting)
  8 | - [Telemetry](#telemetry)
  9 | - [Contribution](#contribution)
 10 | ## Motivation
 11 | ### What is a "Chore"?
 12 | A "Chore" can really be anything, but most commonly it is just some infrequently, manually run code which achieve a business or development goal.
 13 | 
 14 | For example: updating a config value in a database that does not yet have a UI (perhaps due to time constraints) is a great use for a chore. A chore could be created that accepts the desired value and runs the update query.
 15 | 
 16 | ### What problem does ChoreRunner solve?
 17 | The primary fast alternative to extensive development for some infrequent business need tends to be a direct prod-shell or prod-db connection, which is inherently insecure and dangerous.
 18 | Many fast-moving startups or companies are ok with this access for developers, and that's fine. But many companies have regulations that they must follow, or do not want to take the risk of a developer mistake while working in these environments.
 19 | 
 20 | ChoreRunner allows the rapid creation, testing, and reviewing of code chores, along with a bundled UI for running them that accepts a variety of input types,
 21 | with the goal of finding a "sweet spot" of safety and speed when solving such problems.
 22 | 
 23 | ### Shells vs Chores
 24 | - Remote shells skip testing and review processes that could detect issues with the code being executed. Chores are easily tested and reviewed, and tested/reviewed code is safer than untested and unreviewed code.
 25 | - Remote-shell access is a common security audit issue. To comply with security requirements such as PCI-DSS, they might need to be restricted. Chores are a normal part of your app, with controlled behavior like any other admin page, and will not flag most security audits (depending on how you use them).
 26 | - Two developers could unwittingly step on each other's toes if using remote shells in the same app simultaneously. Chores have built-in protections for this.
 27 | - A common reason for using shells is the lack of developer bandwidth to create specific admin functionality for an uncommon task. ChoreRunner ships with a LiveView UI that generates input forms automatically, and lets you track chore progress.
 28 | ## Installation
 29 | Add `chore_runner` to your deps.
 30 | ```elixir
 31 | {:chore_runner, "~> 0.1.3"}
 32 | ```
 33 | Add `ChoreRunner` to your supervision tree, after your app's `PubSub`:
 34 | ```elixir
 35 | children = [
 36 |   {Phoenix.PubSub, [name: MyApp.PubSub]},
 37 |   {ChoreRunner, [pubsub: MyApp.PubSub]},
 38 | ]
 39 | ```
 40 | Decide your app's chore namespace and maybe write an example chore:
 41 | ```elixir
 42 | defmodule MyApp.Chores.MyFirstChore do
 43 |   use ChoreRunner.Chore
 44 |   # Chore namespace is MyApp.Chores
 45 |   def run(_), do: :ok
 46 | end
 47 | ```
 48 | Add the UI to your router, passing `otp_app`, `chore_root`, and `pubsub` keys in the session:
 49 | ```elixir
 50 | @chore_session %{"otp_app" => :my_app, "chore_root" => MyApp.Chores, "pubsub" => MyApp.PubSub}
 51 | scope "/" do
 52 |   pipe_through :browser
 53 | 
 54 |   live_session :chores, session: @chore_session do
 55 |     live "/chores", ChoreRunnerUI.ChoreLive, :index
 56 |     # Optional, use if you want to use the downloads feature
 57 |     live "/chores/downloads", ChoreRunnerUI.DownloadsLive, :index
 58 |   end
 59 | end
 60 | ```
 61 | ### NOTE
 62 | Your Phoenix app must be LiveView-enabled for the UI to work properly.
 63 | 
 64 | You can now visit your UI at the route specified.
 65 | 
 66 | ## Writing a Chore
 67 | The most basic chore module looks like this
 68 | ```elixir
 69 | defmodule MyApp.Chores.BasicChore do
 70 |   use ChoreRunner.Chore
 71 | 
 72 |   def run(_) do
 73 |   # ...
 74 |   end
 75 | end
 76 | ```
 77 | 
 78 | Besides `run/1`, there are two other callbacks that you can implement
 79 | 
 80 | ### `input/0`
 81 | 
 82 | ```elixir
 83 | defmodule MyApp.Chores.BasicChore do
 84 |   use ChoreRunner.Chore
 85 | 
 86 |   def input do
 87 |     [
 88 |       string(:my_string),
 89 |       int(:my_int),
 90 |       float(:my_float),
 91 |       bool(:my_bool),
 92 |       file(:my_file),
 93 |     ]
 94 |   end
 95 | 
 96 |   def run(_inputs) do
 97 |   # ...
 98 |   end
 99 | end
100 | ```
101 | 
102 | The input callback lets you define expected inputs to the chore using input functions imported from ChoreRunner.Input. Input not defined in the callback will be discarded when passed to a chore through `ChoreRunner.run_chore/2`. The 5 supported input types are:
103 | - string
104 | - int
105 | - float
106 | - bool
107 | - file
108 | 
109 | Input functions also accept an optional keyword list of options as a second argument. The supported keys are:
110 | - :description — a description of an input
111 | - :validators — a list of functions, either captured or anonymous, that can be used to transform and validate any provided input.
112 |   ```elixir
113 |   def input do
114 |     [
115 |       string(:name, validators: [&check_length/1, & {:ok, String.capitalize(&1)}]),
116 |     ]
117 |   end
118 | 
119 |   defp check_length(string) do
120 |     if String.length(string) < 3 do
121 |       {:error, "Must be 3 or more characters in lenth"}
122 |     else
123 |       :ok
124 |     end
125 |   end
126 |   ```
127 |   Each input type has a default validator that are always run, which do basic type validation.
128 | ### `restriction/0`
129 | The restriction callback configures each chore's concurrency restriction. Concurrency restriction potentially prevents a chore from running depending on what chores are currently running. This includes chores running on other nodes. It supports 3 valid return values:
130 | - `def restriction, do: :none`
131 | 
132 |   The chore has no restrictions. Multiple of this chore can be run similtaneously.
133 | - `def restriction, do: :self`
134 | 
135 |   Only one of this specific chore is allowed to run at a time.
136 | - `def restriction, do: :global`
137 | 
138 |   Only one :global chore can run at a time, even between different chores. This does not prevent other non-global chores from running.
139 | 
140 | ### `run/1`
141 | The meat of your chore will reside in the `run/1` callback. When you run a chore through the UI, that calls `ChoreRunner.run_chore/2`, which eventually calls out to your `run/1` callback. It accepts an atom-keyed map of expected input, defined by the `input` callback. Input presence in the map is not garaunteed, but you are garaunteed to only receive input specified in the callback. Any return value is is stored in the chore struct via the reporter, broadcasted on the pubsub, and also directly passed to the configured chore resolution handler on chore completion.
142 | 
143 | ## Chore Reporting
144 | `use ChoreRunner.Chore` imports the following functions for use in the `run/1` callback:
145 | - `log(message)`
146 | 
147 |   Logs a timestamped string
148 | - `set_counter(counter_key, counter_value)`
149 | 
150 |   Sets the specified counter to the provided value
151 | - `inc_counter(counter_key, value_to_increment_by)`
152 | 
153 |   Increments the specified counter by the provided value. If the value does not exist, the value defaults to 0, then is incremented.
154 | 
155 | These functions work in both the main chore process, and certain spawned processes such as via `Task.async_stream` for parellelization. Attempting to call these functions outside of those conditions will result in an exception.
156 | 
157 | ## File Downloads
158 | `use ChoreRunner.Chore` also imports the function `create_download(filename, opts)`.
159 | This allows your chores to save files which can be downloaded right after they are created, either via a link on the chore progress element on `ChoreLive` liveview page, or from the dedicated `DownloadsLive` liveview page.
160 | 
161 | To use, simply provide a filename and either a path to a file, or a file body. Filenames do not need to be unique, and chores know which files they created automatically (Though a file does not know its parent chore).
162 | ```elixir
163 | # Local file path
164 | create_download("mytextfile.txt", path: "path/to/file.txt")
165 | 
166 | # Binary body
167 | create_download("mytextfile.txt", body: "this is my text file!")
168 | ```
169 | 
170 | The download is saved and loaded using the configured `storage service`.
171 | 
172 | The default `storage service` is `ChoreRunner.Downloads.TemporaryDiskStorageService`,
173 | an ephemeral local disk solution that is multi-node compatible out of the box!
174 | 
175 | You may implement your own solution—for example, uploading files to a cloud platform—by implementing the callbacks specified in the `ChoreRunner.Downloads.StorageService` behaviour.
176 | You can then configure the global `storage_service` in your application config.
177 | 
178 | `config :chore_runner, :storage_service, MyStorageService`
179 | 
180 | ## Telemetry
181 | The following telemetry events are sent from the `ChoreRunner.Reporter`
182 | - `[:chore_runner, :reporter, :chore_failed]`
183 |   - Emitted when chore has failed.
184 |   - Sends `%{state: chore_state, error_reason: reason}`.
185 | - `[:chore_runner, :reporter, :chore_finished]`
186 |   - Emitted when chore has finished.
187 |   - Sends `%Chore{result: nil}` where the result is set to nil to avoid sending large results through telemetry.
188 | - `[:chore_runner, :reporter, :init]`
189 |   - Emitted when the reporter is started.
190 |   - Sends `%{chore: chore, opts: init_opts}`.
191 | - `[:chore_runner, :reporter, :log]`
192 |   - Emitted when a log is added.
193 |   - Sends `%{state: chore_state}`.
194 | - `[:chore_runner, :reporter, :start_chore]`
195 |   - Emitted when a chore is started.
196 |   - Sends `%{state: chore_state}`.
197 | - `[:chore_runner, :reporter, :stop_chore]`
198 |   - Emitted when a chore is stopped.
199 |   - Sends `%{status: status, state: chore_state}` where state is `:ok | :error`.
200 | - `[:chore_runner, :reporter, :update_counter]`
201 |   - Emitted when counter is updated.
202 |   - Sends `%{state: chore_state}`.
203 | 
204 | ## Contribution
205 | 
206 | Unfortunately, we cannot accept pull requests at this time. However, we will adress any and all issues opened related to bugs or ideas/features.


--------------------------------------------------------------------------------
/assets/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "assets",
 3 |   "version": "1.0.0",
 4 |   "description": "",
 5 |   "main": "index.js",
 6 |   "scripts": {
 7 |     "webpack": "webpack",
 8 |     "delete-mainjs": "rm -rf ../dist/priv/dist/main.js",
 9 |     "watch-scss": "nodemon --watch ./ --ext scss --ignore dist --exec \"npm run webpack && rm -rf ../priv/css/main.js\""
10 |   },
11 |   "keywords": [],
12 |   "author": "",
13 |   "license": "ISC",
14 |   "devDependencies": {
15 |     "css-loader": "^6.3.0",
16 |     "mini-css-extract-plugin": "^2.4.1",
17 |     "nodemon": "^2.0.13",
18 |     "optimize-css-assets-webpack-plugin": "^6.0.1",
19 |     "sass": "^1.42.1",
20 |     "sass-loader": "^12.1.0",
21 |     "style-loader": "^3.3.0",
22 |     "webpack": "^5.57.1",
23 |     "webpack-cli": "^4.8.0"
24 |   }
25 | }
26 | 


--------------------------------------------------------------------------------
/assets/src/index.js:
--------------------------------------------------------------------------------
1 | import "./scss/index.scss";
2 | 
3 | export default {};
4 | 


--------------------------------------------------------------------------------
/assets/src/scss/button.scss:
--------------------------------------------------------------------------------
 1 | @import "variables";
 2 | 
 3 | button {
 4 |   background: #023e73;
 5 |   color: white;
 6 |   border-radius: 4px;
 7 |   padding: 6px 15px 6px 15px;
 8 |   font-family: $font-primary;
 9 | }
10 | 
11 | .file-button {
12 |   background: #023e73;
13 |   color: white;
14 |   border-radius: 4px;
15 |   padding: 6px 15px 6px 15px;
16 |   font-family: $font-primary;
17 |   cursor:pointer;
18 | }
19 | 
20 | .file-button-delete{
21 |   background:#730202;
22 |   margin-left: 2em;
23 | }
24 | 


--------------------------------------------------------------------------------
/assets/src/scss/chore-item.scss:
--------------------------------------------------------------------------------
 1 | @import "variables";
 2 | 
 3 | .chore-item {
 4 |   margin: 5px 20px;
 5 |   margin-bottom: 0.1em;
 6 |   border: 1px solid $border-color;
 7 |   border-radius: 4px;
 8 |   background-color: white;
 9 |   display: flex;
10 |   flex-direction: column;
11 | 
12 |   &:first-of-type {
13 |     margin-top: 20px;
14 |   }
15 | }
16 | 
17 | .chore-item-name {
18 |   background-color: $pepdirect-gray6;
19 |   padding: 16px 24px;
20 |   display: flex;
21 |   justify-content: space-between;
22 |   align-items: center;
23 | 
24 |   & span {
25 |     text-transform: uppercase;
26 |     font-family: $font-primary;
27 |     font-weight: 400;
28 |     color: $pepdirect-gray1;
29 |   }
30 | }
31 | 
32 | .chore-item-content-container {
33 |   display: flex;
34 | }
35 | 
36 | .chore-item-recentlog {
37 |   font-family: Courier New, monospace;
38 |   padding: 20px 24px;
39 |   color: $pepdirect-gray2;
40 |   width: 50%;
41 | }
42 | 
43 | .chore-item-stats {
44 |   width: 50%;
45 |   display: flex;
46 |   flex-wrap: wrap;
47 |   padding: 10px 24px;
48 | }
49 | 
50 | .chore-item-stats-scalar {
51 |   padding: 5px;
52 |   margin: 5px;
53 |   border: 1px solid $border-color;
54 |   border-radius: 4px;
55 |   flex: 0 0 45%;
56 |   min-height: 30px;
57 |   display: flex;
58 |   flex-direction: column;
59 | 
60 |   & span:first-child {
61 |     font-family: $font-primary;
62 |     font-size: 12px;
63 |     color: $pepdirect-gray3;
64 |   }
65 | 
66 |   & span:nth-child(2) {
67 |     font-family: $font-primary;
68 |     font-size: 28px;
69 |   }
70 | }
71 | 
72 | .chore-downloads {
73 |   padding: 2px;
74 |   padding-left: 1em;
75 |   padding-right: 1em;
76 |   background-color: $pepdirect-gray6;
77 |   border-top: 1px black;
78 | }
79 | .chore-downloads a {
80 |   text-decoration: underline;
81 |   cursor:pointer;
82 |   margin-right: 1em;
83 | }


--------------------------------------------------------------------------------
/assets/src/scss/colors.scss:
--------------------------------------------------------------------------------
1 | $border-color: #d9d9d9;
2 | $pepdirect-gray1: #262626;
3 | $pepdirect-gray2: #595959;
4 | $pepdirect-gray3: #828282;
5 | $pepdirect-gray6: #f0f0f0;
6 | $pepdirect-gray7: #f9f9f9;
7 | 


--------------------------------------------------------------------------------
/assets/src/scss/container.scss:
--------------------------------------------------------------------------------
 1 | @import "variables";
 2 | 
 3 | .chore-container {
 4 |   width: 100%;
 5 |   height: 100vh;
 6 |   max-width: 100vw !important;
 7 |   margin: 0;
 8 |   display: flex;
 9 |   justify-content: flex-start;
10 | }
11 | 
12 | .chore-menu {
13 |   background-color: $pepdirect-gray6;
14 |   padding: 10px 20px;
15 |   min-width: 250px;
16 | }
17 | 
18 | .running-chores-container {
19 |   flex: 1;
20 | }
21 | 


--------------------------------------------------------------------------------
/assets/src/scss/downloads.scss:
--------------------------------------------------------------------------------
 1 | .downloads-header{
 2 |   font-size: 2em;
 3 |   font-weight: bolder;
 4 | }
 5 | 
 6 | .flex-row-between{
 7 |   margin-left: 1em;
 8 |   margin-right: 1em;
 9 |   display: flex;
10 |   flex-direction: row;
11 |   justify-content: space-between;
12 |   align-items: center;
13 | }
14 | 
15 | .download-name {
16 |   background-color: $pepdirect-gray6;
17 |   padding: 16px 24px;
18 |   display: flex;
19 |   justify-content: space-between;
20 |   align-items: center;
21 | 
22 |   & span {
23 |     font-family: $font-primary;
24 |     font-weight: 400;
25 |     color: $pepdirect-gray1;
26 |   }
27 | }


--------------------------------------------------------------------------------
/assets/src/scss/form.scss:
--------------------------------------------------------------------------------
 1 | .chore-form-flexbox {
 2 |   display: flex;
 3 |   flex-direction: column;
 4 |   justify-content: space-between;
 5 |   min-height: 5em;
 6 | }
 7 | 
 8 | .chore-form-select {
 9 |   margin-bottom: 1em;
10 |   color: #595959;
11 |   border: 1px solid $border-color;
12 |   border-radius: 4px;
13 |   padding: 9px 15px;
14 | }
15 | 
16 | .chore-form-label {
17 |   color: #262626;
18 |   font-size: 12px;
19 |   font-family: Source Sans Pro;
20 |   font-weight: 700;
21 |   margin-bottom: 8px;
22 | }
23 | 
24 | .chore-form-input-wrapper {
25 |   display: flex;
26 |   flex-direction: column;
27 |   flex: 1;
28 |   margin-top: 10px;
29 | }
30 | 
31 | .chore-inputs-container {
32 |   padding: 24px;
33 |   border: 1px solid $border-color;
34 |   border-radius: 4px;
35 |   background-color: white;
36 | }
37 | 
38 | .chore-form-input {
39 |   border: 1px solid $border-color;
40 |   padding: 6px 12px;
41 | }
42 | 
43 | .chore-form-flexbox {
44 |   display: flex;
45 |   flex-direction: column;
46 | }
47 | 
48 | .chore-form-inputs-flexbox {
49 |   text-align: left;
50 |   display: flex;
51 |   flex-direction: column;
52 | }
53 | 
54 | .chore-form-file-input-wrapper {
55 |   display: flex;
56 |   flex-direction: column;
57 |   justify-content: center;
58 |   align-items: stretch;
59 | }
60 | 
61 | .chore-form-top-level-input-wrapper {
62 |   width: 100%;
63 |   min-height: 3em;
64 | }
65 | 
66 | .chore-form-input-errors-wrapper {
67 |   display: flex;
68 |   margin-top: 10px;
69 |   flex-direction: column;
70 | }
71 | 
72 | .chore-form-file-input {
73 |   color: white;
74 | }
75 | 
76 | .chore-run-submit-button {
77 |   margin-top: 24px;
78 |   width: 100%;
79 | }
80 | 
81 | .alert {
82 |   padding: 5px !important;
83 |   margin-bottom: 10px !important;
84 |   max-width: 400px;
85 | }
86 | 
87 | progress {
88 |   width: 100%;
89 | }
90 | 


--------------------------------------------------------------------------------
/assets/src/scss/index.scss:
--------------------------------------------------------------------------------
 1 | @import url("https://fonts.googleapis.com/css?family=Source+Sans+Pro:300,400,600,700,800,900&display=swap");
 2 | @import "button";
 3 | @import "container";
 4 | @import "typography";
 5 | @import "form";
 6 | @import "chore-item";
 7 | @import "modal";
 8 | @import "downloads";
 9 | 
10 | .running-chores {
11 |   list-style-type: none;
12 |   background-color: white;
13 |   padding: 0.25em;
14 |   padding-top: 0.5em;
15 |   height: 40em;
16 |   overflow-y: scroll;
17 |   margin-top: 0;
18 |   height: 100%;
19 | }
20 | 


--------------------------------------------------------------------------------
/assets/src/scss/modal.scss:
--------------------------------------------------------------------------------
 1 | .chore-modal-backdrop {
 2 |   position: absolute;
 3 |   top: 0;
 4 |   left: 0;
 5 |   z-index: 100;
 6 |   background-color: black;
 7 |   opacity: 0.3;
 8 |   display: flex;
 9 |   justify-content: center;
10 |   align-items: center;
11 |   height: 100%;
12 |   width: 100%;
13 | }
14 | 
15 | .chore-modal-container {
16 |   position: absolute;
17 |   top: 50%;
18 |   left: 50%;
19 |   transform: translate(-50%, -50%);
20 |   z-index: 101;
21 |   background-color: $pepdirect-gray7;
22 |   box-shadow: 1px 2px 4px rgba(0, 0, 0, 0.15);
23 |   min-height: 200px;
24 |   min-width: 50%;
25 |   max-height: 400px;
26 |   overflow-y: scroll;
27 | }
28 | 
29 | .chore-modal-header {
30 |   padding: 10px;
31 |   background-color: $pepdirect-gray7;
32 |   border-bottom: 1px solid #d9d9d9;
33 |   display: flex;
34 |   justify-content: space-between;
35 | 
36 |   & h2 {
37 |     font-weight: 500;
38 |     font-family: $font-primary !important;
39 |     color: $pepdirect-gray1;
40 |     font-size: 16px;
41 |   }
42 | 
43 |   & button {
44 |     border: none;
45 |     background-color: transparent;
46 |     color: black;
47 |     padding: 0;
48 |     color: $pepdirect-gray1;
49 |     font-family: $font-primary;
50 |   }
51 | }
52 | 
53 | .chore-modal-text-container {
54 |   min-height: 200px;
55 |   min-width: 300px;
56 |   max-height: 300px;
57 |   padding: 10px;
58 | 
59 |   & p {
60 |     font-family: Courier New, monospace;
61 |   }
62 | }
63 | 
64 | .chore-modal-bottom-container {
65 |   padding: 10px;
66 |   display: flex;
67 |   justify-content: flex-end;
68 |   background-color: $pepdirect-gray6;
69 |   border-top: 1px solid #d9d9d9;
70 | }
71 | 


--------------------------------------------------------------------------------
/assets/src/scss/typography.scss:
--------------------------------------------------------------------------------
1 | @import "variables";
2 | 
3 | .my-chores-heading {
4 |   color: #262626;
5 |   font-size: 24px;
6 |   margin-bottom: 20px;
7 |   font-family: $font-primary;
8 | }
9 | 


--------------------------------------------------------------------------------
/assets/src/scss/variables.scss:
--------------------------------------------------------------------------------
 1 | @import "./colors";
 2 | 
 3 | $margin-base: 10px;
 4 | $padding-base: 10px;
 5 | 
 6 | $font-primary: "Source Sans Pro", "Helvetica Neue", "Helvetica", "Arial",
 7 |   sans-serif; // DM Sans
 8 | 
 9 | $z-index-modal: 10001;
10 | $z-index-header: $z-index-modal - 1;
11 | 
12 | // BREAKPOINT WIDTHS
13 | // simplified version of https://gist.github.com/gokulkrishh/242e68d1ee94ad05f488
14 | $mobile-min: 320px;
15 | $mobile-max: 767px;
16 | $tablet-min: 768px;
17 | $tablet-max: 1024px;
18 | $laptop-min: 1025px;
19 | 
20 | // BREAKPOINTS
21 | @mixin mobile {
22 |   @media (min-width: #{$mobile-min}) and (max-width: #{$mobile-max}) {
23 |     @content;
24 |   }
25 | }
26 | 
27 | @mixin tablet {
28 |   @media (min-width: #{$tablet-min}) and (max-width: #{$tablet-max}) {
29 |     @content;
30 |   }
31 | }
32 | 
33 | @mixin laptop {
34 |   @media (min-width: #{$laptop-min}) {
35 |     @content;
36 |   }
37 | }
38 | 
39 | @mixin not-laptop {
40 |   @media (max-width: #{$laptop-min}) {
41 |     @content;
42 |   }
43 | }
44 | 
45 | @mixin not-mobile {
46 |   @media (min-width: #{$tablet-min}) {
47 |     @content;
48 |   }
49 | }
50 | 


--------------------------------------------------------------------------------
/assets/webpack.config.js:
--------------------------------------------------------------------------------
 1 | const path = require("path");
 2 | const MiniCssExtractPlugin = require("mini-css-extract-plugin");
 3 | 
 4 | module.exports = {
 5 |   mode: "production",
 6 |   entry: path.resolve(__dirname, "./src/index.js"),
 7 |   output: {
 8 |     path: path.resolve(__dirname, "../priv/css"),
 9 |     filename: "[name].js",
10 |     publicPath: "/dist/",
11 |   },
12 |   plugins: [
13 |     new MiniCssExtractPlugin({
14 |       filename: "[name].css",
15 |       chunkFilename: "[id].css",
16 |     }),
17 |   ],
18 |   module: {
19 |     rules: [
20 |       {
21 |         test: /\.scss$/,
22 |         use: [
23 |           "style-loader",
24 |           MiniCssExtractPlugin.loader,
25 |           {
26 |             loader: "css-loader",
27 |           },
28 |           {
29 |             loader: "sass-loader",
30 |           },
31 |         ],
32 |       },
33 |     ],
34 |   },
35 | };
36 | 


--------------------------------------------------------------------------------
/lib/chore_runner.ex:
--------------------------------------------------------------------------------
  1 | defmodule ChoreRunner do
  2 |   @moduledoc """
  3 |   A framework and library for productively writing and running code "Chores".
  4 | 
  5 |   A "Chore" can really be anything, but most commonly it is just some infrequently, manually run code which achieve a business or development goal.
  6 | 
  7 |   For example: updating a config value in a database that does not yet have a UI (perhaps due to time constraints) is a great use for a chore.
  8 |   A chore could be created that accepts the desired value and runs the update query.
  9 | 
 10 |   Usually, the alternative to this would be a direct prod-shell or prod-db connection, which is inherently insecure and dangerous.
 11 |   Many fast-moving startups or companies are ok with this access for developers, and that's fine.
 12 | 
 13 |   But many companies have regulations that they must follow, or do not want to take the risk of a developer mistake while working in these environments.
 14 | 
 15 |   In these cases, ChoreRunner allows the rapid creation, testing, and reviewing of code chores, along with a bundled UI for running them that accepts a variety of input types,
 16 |   with the goal of finding a "sweet spot" of safety and speed when solving such problems.
 17 |   ## Getting Started
 18 |   Add `ChoreRunner` to your supervision tree, after your app's `PubSub`:
 19 |   ```
 20 |   children = [
 21 |     {Phoenix.PubSub, [name: MyApp.PubSub]},
 22 |     {ChoreRunner, [pubsub: MyApp.PubSub]},
 23 |   ]
 24 |   ```
 25 |   ## Writing a chore
 26 |   ```
 27 |   defmodule MyApp.MyChore do
 28 |     use ChoreRunner.Chore
 29 | 
 30 |     input :my_file, :file
 31 | 
 32 |     def run(%{my_file: path}}) do
 33 |       path
 34 |       |> File.read!()
 35 |       |> parse_file()
 36 |       |> do_stuff()
 37 |     end
 38 |   end
 39 |   ```
 40 |   Example of running this Chore:
 41 |   ```
 42 |   iex> ChoreRunner.run_chore(MyApp.MyChore, %{my_file: file}, :infinity)
 43 |   {:ok, %Chore{}}
 44 |   ```
 45 |   """
 46 |   alias ChoreRunner.{Chore, ReporterSupervisor, Reporter}
 47 | 
 48 |   @doc false
 49 |   def child_spec(opts) do
 50 |     %{
 51 |       id: ChoreRunner.Supervisor,
 52 |       start: {ChoreRunner.Supervisor, :start_link, [opts]}
 53 |     }
 54 |   end
 55 | 
 56 |   @doc """
 57 |   List the currently running chores on all nodes.
 58 |   """
 59 |   @spec list_running_chores() :: [Chore.t()]
 60 |   def list_running_chores do
 61 |     __MODULE__
 62 |     |> :pg.get_members(Reporter)
 63 |     |> Enum.map(&:gen_server.send_request(&1, :chore_state))
 64 |     |> Enum.flat_map(fn request ->
 65 |       case :gen_server.receive_response(request, 1000) do
 66 |         {:reply, chore} -> [chore]
 67 |         :timeout -> []
 68 |         {:error, _reason} -> []
 69 |       end
 70 |     end)
 71 |   end
 72 | 
 73 |   @doc """
 74 |   Returns the pubsub topic used for a specific chore, or all chores if given the atom `:all`
 75 |   """
 76 |   @spec chore_pubsub_topic(Chore.t() | :all) :: String.t()
 77 |   def chore_pubsub_topic(:all), do: "chore_runner:*"
 78 | 
 79 |   def chore_pubsub_topic(%Chore{id: id}) do
 80 |     "chore_runner:id-#{id}"
 81 |   end
 82 | 
 83 |   @doc """
 84 |   Returns the pubsub topic used for file downloads
 85 |   """
 86 |   def downloads_pubsub_topic, do: "chore_runner_downloads:*"
 87 | 
 88 |   @doc """
 89 |   Runs the given chore module as a chore.
 90 |   Accepts an input map with either string or atom keys as well as a keyword list of options.
 91 |   Returns a `%ChoreRunner.Chore{}` struct.
 92 | 
 93 |   Input map keys must match one of the inputs defined in the provided chore module.
 94 |   If not, the input under the unmatched key is discarded.
 95 |   Matched input will have default validations run on them, as well custom validations declared in the chore module.
 96 |   If any inputs fail validation, the chore will not run, and instead an error tuple will be returned.
 97 |   If all validations pass, the chore will then be run.
 98 | 
 99 |   Opts
100 |     * extra_data: Map of arbitrary data to be forwarded to telemetry events and result handlers.
101 |       Useful for storing chore session information, such as identifying who or what ran the chore.
102 |     * result_handler: Single arity anonymous function or MFA of a single arity function
103 |       that is called once the chore is finished. The function will take the %Chore{}.
104 |   """
105 |   @spec run_chore(module(), map(), Keyword.t()) :: {:ok, Chore.t()} | {:error, any()}
106 |   def run_chore(chore_mod, input, opts \\ []) do
107 |     opts = merge_default_opts(opts, chore_mod)
108 |     extra_data = Keyword.get(opts, :extra_data, %{})
109 |     chore = %Chore{mod: chore_mod, id: gen_id(), inputs: input, extra_data: extra_data}
110 | 
111 |     with {:ok, validated_input} <- Chore.validate_input(chore, input),
112 |          {:ok, updated_chore = %Chore{reporter: pid}} when not is_nil(pid) <-
113 |            do_start_reporter(chore, opts),
114 |          {:ok, started_chore} <- do_start_chore(updated_chore, validated_input, opts) do
115 |       {:ok, started_chore}
116 |     end
117 |   end
118 | 
119 |   defp merge_default_opts(opts, chore_mod) do
120 |     Keyword.put_new_lazy(opts, :result_handler, fn ->
121 |       if function_exported?(chore_mod, :result_handler, 1) do
122 |         &chore_mod.result_handler/1
123 |       else
124 |         & &1
125 |       end
126 |     end)
127 |   end
128 | 
129 |   @doc """
130 |   Stops the provided chore by terminating both the chore task and the reporter.
131 |   Returns `:ok` if successful, and `:error` if not successful
132 |   """
133 |   @spec stop_chore(Chore.t()) :: :ok | :error
134 |   def stop_chore(%Chore{reporter: pid}) do
135 |     GenServer.call(pid, :stop_chore)
136 |   end
137 | 
138 |   @doc false
139 |   def gen_id do
140 |     32
141 |     |> :crypto.strong_rand_bytes()
142 |     |> Base.hex_encode32(case: :lower, padding: false)
143 |   end
144 | 
145 |   defp do_start_reporter(%Chore{} = chore, opts) do
146 |     with {:ok, pid} <-
147 |            DynamicSupervisor.start_child(
148 |              ReporterSupervisor,
149 |              {Reporter, Keyword.put(opts, :chore, chore)}
150 |            ),
151 |          :ok <- :pg.join(ChoreRunner, Reporter, pid) do
152 |       {:ok, %Chore{chore | reporter: pid}}
153 |     end
154 |   end
155 | 
156 |   defp do_start_chore(%Chore{reporter: reporter_pid}, input, opts) do
157 |     # Start the task from the reporter so that the task reports to the reporter server
158 | 
159 |     {:ok, GenServer.call(reporter_pid, {:start_chore_task, input, opts})}
160 |   end
161 | end
162 | 


--------------------------------------------------------------------------------
/lib/chore_runner/chore.ex:
--------------------------------------------------------------------------------
  1 | defmodule ChoreRunner.Chore do
  2 |   @moduledoc """
  3 |   Behaviour and DSL for chores.
  4 |   """
  5 |   require ChoreRunner.DSL
  6 |   alias ChoreRunner.{DSL, Input}
  7 | 
  8 |   defstruct extra_data: %{},
  9 |             finished_at: nil,
 10 |             id: nil,
 11 |             inputs: %{},
 12 |             logs: [],
 13 |             mod: nil,
 14 |             reporter: nil,
 15 |             result: nil,
 16 |             started_at: nil,
 17 |             task: nil,
 18 |             values: %{},
 19 |             downloads: []
 20 | 
 21 |   defmacro __using__(opts), do: DSL.using(opts)
 22 | 
 23 |   @type unix_timestamp :: integer()
 24 |   @type t :: %__MODULE__{
 25 |           extra_data: map(),
 26 |           finished_at: DateTime.t(),
 27 |           id: String.t(),
 28 |           inputs: map(),
 29 |           logs: [{unix_timestamp, String.t()}],
 30 |           mod: module(),
 31 |           reporter: pid(),
 32 |           result: any(),
 33 |           started_at: DateTime.t(),
 34 |           task: Task.t(),
 35 |           values: %{atom() => number()},
 36 |           downloads: [ChoreRunner.Downloads.StorageService.file()]
 37 |         }
 38 | 
 39 |   @doc """
 40 |   An optional callback function for defining a chore restriction.
 41 | 
 42 | 
 43 |   The restriction can be either :none, :self, or :global
 44 |   - `:none` is no restrictions
 45 |   - `:self` prevents more than one of the same chore from running simultaneously across all connected nodes
 46 |   - `:global` prevents more than one of all chores with the restriction `:global` from running simultaneously across all connected nodes. This restriction does not affect non-`:global` chores.
 47 |   If this callback is not defined, the default return is `:self`
 48 |   """
 49 |   @callback restriction :: :none | :self | :global
 50 |   @doc """
 51 |   An optional callback function for defining a chore's inputs.
 52 | 
 53 | 
 54 |   Expects a list of input function calls.
 55 |   The input functions provided are `string`, `int`, `float`, `file`, and `bool`.
 56 |   All input functions follow the same syntax.
 57 |   For example:
 58 |   ```
 59 |   def inputs do
 60 |     [
 61 |       string(:name),
 62 |       int(:name2, [some: :option])
 63 |     ]
 64 |   end
 65 |   ```
 66 |   The supported options are
 67 |   - `:description` — a string description of the input, for UI use
 68 |   - `:validators` — a list of anonymous or captured validator functions.
 69 |     Valiator functions should accept a single argument as a parameter, but can return a variety of things, including:
 70 |     - an `{:ok, value}`, or `{:error, reason}` tuple
 71 |     - an `:ok` or `:error` atom
 72 |     - a `true` or `false`
 73 |     - any erlang value, or nil
 74 |     The positive values (`:ok`, `true`, non-falsey values) pass validation.
 75 |     The negative values (`:error`, `false`, `nil`) fail validation
 76 |     If a value is passed back as part of an {:ok, value} tuple, or by itself, that value is treated as the new value of the given input. This way, validators can also transform input if needed.
 77 |   If this callback is not defined, the default return is `[]`, or no inputs.
 78 |   """
 79 |   @callback inputs :: [Input.t()]
 80 |   @doc """
 81 |   A non-optional callback used to contain the main Chore logic.
 82 | 
 83 | 
 84 |   Accepts a map of input, always atom keyed. (When calling ChoreRunner.run_chore/2, a string keyed map will be intelligently converted to an atom-keyed map automatically)
 85 |   Only keys defined in the `inputs/0` callback will be present in the input map, but defined inputs are not garaunteed to be present.
 86 |   The chore callback has access to several `Reporter` functions, used for live chore metrics and loggin.
 87 |   These functions are:
 88 |   - `log(message)` — Logs a string message with timestamp
 89 |   - `set_counter(name, value)` — Sets a named counter, expects an atom for a name and a number for a value
 90 |   - `inc_counter(name, inc_value)` — Increments a named counter. If the counter does not exist, it will default to 0, and then be incremented. Used negative values for decrements.
 91 |   - `report_failed(reason_message)` — Fails a chore, marking it as failed.
 92 |   The return value of the `run/1` callback will be stored in the chore struct and forwarded to the final chore handling function.
 93 |   """
 94 |   @callback run(map()) :: {:ok, any()} | {:error, any()}
 95 | 
 96 |   @doc """
 97 |   Optional callback to be called once the chore has been completed.
 98 |   """
 99 |   @callback result_handler(t()) :: any()
100 |   @optional_callbacks result_handler: 1
101 | 
102 |   def validate_input(%__MODULE__{mod: mod}, input) do
103 |     expected_inputs = mod.inputs()
104 | 
105 |     Enum.reduce(input, {%{}, []}, fn {key, val}, {validated_inputs, errors_acc} ->
106 |       with {:ok, {type, name, opts}} <- verify_valid_input_name(expected_inputs, key),
107 |            {:ok, validated_value} <- validate_input(name, val, type, opts) do
108 |         {Map.put(validated_inputs, name, validated_value), errors_acc}
109 |       else
110 |         {:error, :invalid_input_name} ->
111 |           {validated_inputs, errors_acc}
112 | 
113 |         {:error, name, errors} ->
114 |           {validated_inputs, [{name, errors} | errors_acc]}
115 |       end
116 |     end)
117 |     |> case do
118 |       {final_inputs, []} -> {:ok, final_inputs}
119 |       {_, errors} -> {:error, errors}
120 |     end
121 |   end
122 | 
123 |   defp verify_valid_input_name(expected_inputs, key) do
124 |     Enum.find_value(expected_inputs, fn {type, name, opts} ->
125 |       if name == key or "#{name}" == key do
126 |         {:ok, {type, name, opts}}
127 |       else
128 |         false
129 |       end
130 |     end)
131 |     |> case do
132 |       nil -> {:error, :invalid_input_name}
133 |       {:ok, res} -> {:ok, res}
134 |     end
135 |   end
136 | 
137 |   defp validate_input(name, value, type, opts) do
138 |     [(&Input.validate_field(type, &1)) | Keyword.get(opts, :validators, [])]
139 |     |> Enum.reduce({value, []}, fn validator, {val, errors} ->
140 |       case validator.(val) do
141 |         {:ok, validated_value} -> {validated_value, errors}
142 |         :ok -> {val, errors}
143 |         true -> {val, errors}
144 |         {:error, reason} -> {val, [reason | errors]}
145 |         false -> {val, ["invalid" | errors]}
146 |         nil -> {val, ["invalid" | errors]}
147 |         other -> {other, errors}
148 |       end
149 |     end)
150 |     |> case do
151 |       {final_value, [] = _no_errors} -> {:ok, final_value}
152 |       {_invalid, errors} -> {:error, name, errors}
153 |     end
154 |   end
155 | end
156 | 


--------------------------------------------------------------------------------
/lib/chore_runner/chore_case.ex:
--------------------------------------------------------------------------------
 1 | defmodule ChoreRunner.ChoreCase do
 2 |   use ExUnit.CaseTemplate
 3 | 
 4 |   using do
 5 |     quote do
 6 |       defmacro assert_logged(log, opts \\ []) do
 7 |         quote do
 8 |           logs =
 9 |             ChoreRunner.Reporter.__process_dict_key__()
10 |             |> Process.get()
11 |             |> GenServer.call(:logs)
12 | 
13 |           assert logs =~ unquote(log)
14 |         end
15 |       end
16 |     end
17 |   end
18 | 
19 |   setup do
20 |     pid = start_supervised!(ChoreRunner.ChoreCase.TestReporter)
21 |     Process.put(ChoreRunner.Reporter.__process_dict_key__(), pid)
22 | 
23 |     :ok
24 |   end
25 | end
26 | 


--------------------------------------------------------------------------------
/lib/chore_runner/chore_case/test_reporter.ex:
--------------------------------------------------------------------------------
 1 | defmodule ChoreRunner.ChoreCase.TestReporter do
 2 |   use GenServer
 3 | 
 4 |   def init(_) do
 5 |     {:ok, []}
 6 |   end
 7 | 
 8 |   def start_link(_) do
 9 |     GenServer.start_link(__MODULE__, [])
10 |   end
11 | 
12 |   def handle_cast(event, state), do: {:noreply, [event | state]}
13 | 
14 |   def handle_call({:assert_logged, enum_func}, _, state) do
15 |     {:reply, Enum.find(state, enum_func), state}
16 |   end
17 | 
18 |   def handle_call(:logs, _, state) do
19 |     logs =
20 |       state
21 |       |> Enum.map(fn
22 |         {:log, log, _} -> log
23 |         _ -> nil
24 |       end)
25 |       |> Enum.filter(& &1)
26 |       |> Enum.join("\n")
27 | 
28 |     {:reply, logs, state}
29 |   end
30 | 
31 |   def handle_call(event, _, state), do: {:reply, :ok, [event | state]}
32 | 
33 |   def assert_event(pid, event) do
34 |     GenServer.call(pid, {:assert_event, event})
35 |   end
36 | end
37 | 


--------------------------------------------------------------------------------
/lib/chore_runner/downloads.ex:
--------------------------------------------------------------------------------
 1 | defmodule ChoreRunner.Downloads do
 2 |   alias ChoreRunner.Downloads.StorageService
 3 | 
 4 |   def create_download(filename, opts), do: StorageService.save_file(filename, opts)
 5 | 
 6 |   def list_downloads do
 7 |     with {:ok, local_downloads} <- StorageService.list_files(),
 8 |          {results, _} <-
 9 |            :rpc.multicall(Node.list(), ChoreRunner.Downloads.StorageService, :list_files, []) do
10 |       results
11 |       |> Enum.flat_map(fn
12 |         {:ok, files} -> files
13 |         _ -> []
14 |       end)
15 |       |> Kernel.++(local_downloads)
16 |     end
17 |   end
18 | 
19 |   def delete_download(file) do
20 |     with {:error, _} <- StorageService.delete_file(file),
21 |          {results, _} <-
22 |            :rpc.multicall(Node.list(), ChoreRunner.Downloads.StorageService, :delete_file, [file]) do
23 |       Enum.find(results, {:error, :enoent}, &(&1 == :ok))
24 |     end
25 |   end
26 | end
27 | 


--------------------------------------------------------------------------------
/lib/chore_runner/downloads/storage_service.ex:
--------------------------------------------------------------------------------
 1 | defmodule ChoreRunner.Downloads.StorageService do
 2 |   @typedoc """
 3 |   Must have the appropriate file extension to be considered a valid name.
 4 |   """
 5 |   @type name :: String.t()
 6 |   @type file_path :: String.t()
 7 |   @type body :: binary()
 8 |   @typedoc """
 9 |   While both :path and :body are optional, at least one is required. The application will raise if both are provided.
10 |   """
11 |   @type opts :: [path: file_path(), body: body()]
12 |   @type reason :: any()
13 |   @type file :: %{
14 |           required(:id) => String.t(),
15 |           required(:name) => String.t(),
16 |           required(:type) => String.t(),
17 |           required(:created_at) => DateTime.t(),
18 |           optional(:chore_id) => String.t(),
19 |           optional(atom()) => any()
20 |         }
21 |   @callback save_file(name, opts) :: {:ok, file()} | {:error, reason()}
22 |   @callback list_files() :: {:ok, [file()]} | {:error, reason()}
23 |   @callback delete_file(file()) :: :ok | {:error, reason()}
24 |   @callback file_url(file(), list()) :: String.t()
25 |   # @callback extra_ui_info() :: map()
26 | 
27 |   @storage_service Application.compile_env(
28 |                      :chore_runner,
29 |                      :storage_service,
30 |                      ChoreRunner.Downloads.TemporaryDiskStorageService
31 |                    )
32 | 
33 |   def save_file(name, opts) do
34 |     cond do
35 |       opts[:path] && opts[:body] ->
36 |         raise "Only one of the options :path or :body can be provided to the function ChoreRunner.Downloads.StorageService.save_file/2 at a time."
37 | 
38 |       is_nil(opts[:path]) and is_nil(opts[:body]) ->
39 |         raise "One of the options :path or :body must be provided to the function ChoreRunner.Downloads.StorageService.save_file/2."
40 | 
41 |       true ->
42 |         @storage_service.save_file(name, opts)
43 |     end
44 |   end
45 | 
46 |   defdelegate list_files(), to: @storage_service
47 |   defdelegate delete_file(file), to: @storage_service
48 |   defdelegate file_url(file, opts), to: @storage_service
49 |   # defdelegate extra_ui_info(), to: @storage_service
50 | 
51 |   def find_file(id), do: find_files_by(:id, id) |> List.first()
52 | 
53 |   def find_files_by_chore_id(chore_id), do: find_files_by(:chore_id, chore_id)
54 | 
55 |   defp find_files_by(key, val) do
56 |     with {:ok, files} <- ChoreRunner.Downloads.list_downloads() do
57 |       Enum.filter(files, &(&1[key] == val))
58 |     end
59 |   end
60 | end
61 | 


--------------------------------------------------------------------------------
/lib/chore_runner/downloads/temporary_disk_storage_service.ex:
--------------------------------------------------------------------------------
 1 | defmodule ChoreRunner.Downloads.TemporaryDiskStorageService do
 2 |   alias ChoreRunner.Downloads.StorageService
 3 |   @behaviour StorageService
 4 |   @file_dir_name "chore_runner_temporary_disk_storage_service_directory"
 5 | 
 6 |   @impl StorageService
 7 |   def save_file(name, opts \\ []) do
 8 |     with :ok <- ensure_dir(),
 9 |          id = ChoreRunner.gen_id(),
10 |          file = %{
11 |            id: id,
12 |            name: name,
13 |            type: MIME.from_path(name),
14 |            path: build_write_filepath(id, name)
15 |          },
16 |          :ok <- write_file(file.path, opts[:path], opts[:body]) do
17 |       {:ok, Map.put(file, :created_at, File.stat!(file.path).mtime)}
18 |     end
19 |   end
20 | 
21 |   @impl StorageService
22 |   def list_files do
23 |     case File.ls(dir()) do
24 |       {:ok, files} ->
25 |         {:ok, Enum.map(files, &build_file_from_saved_path/1)}
26 | 
27 |       {:error, :enoent} ->
28 |         {:ok, []}
29 | 
30 |       error ->
31 |         error
32 |     end
33 |   end
34 | 
35 |   @impl StorageService
36 |   def delete_file(%{path: path} = _file), do: File.rm(path)
37 | 
38 |   @impl StorageService
39 |   def file_url(%{id: id} = _file, download_plug_path: download_plug_path),
40 |     do: Path.join(download_plug_path, id)
41 | 
42 |   # @impl StorageService
43 |   # def extra_ui_info do
44 |   #   Application.ensure_started(:sasl)
45 |   #   Application.ensure_started(:os_mon)
46 | 
47 |   #   percentage_available =
48 |   #     :disksup.get_disk_data()
49 |   #     |> List.first()
50 |   #     |> case do
51 |   #       {_, _, percentage_available} ->
52 |   #         "#{percentage_available}%"
53 | 
54 |   #       _ ->
55 |   #         "Unknown"
56 |   #     end
57 | 
58 |   #   %{
59 |   #     "Available Disk Space" => percentage_available
60 |   #   }
61 |   # end
62 | 
63 |   defp write_file(write_path, path, nil) when not is_nil(path), do: File.cp(path, write_path)
64 |   defp write_file(write_path, nil, body) when not is_nil(body), do: File.write(write_path, body)
65 | 
66 |   defp build_file_from_saved_path(path) do
67 |     %{"id" => id, "name" => name} = Regex.named_captures(~r/^(?<id>[\da-z]+)_(?<name>.+)$/, path)
68 |     path = Path.join(dir(), path)
69 |     stat = File.stat!(path)
70 | 
71 |     %{
72 |       id: id,
73 |       name: name,
74 |       type: MIME.from_path(path),
75 |       path: path,
76 |       created_at: stat.mtime |> NaiveDateTime.from_erl!(),
77 |       size: stat.size,
78 |       node: node()
79 |     }
80 |   end
81 | 
82 |   defp build_write_filepath(id, name), do: Path.join(dir(), "#{id}_#{name}")
83 | 
84 |   defp dir, do: Path.join(System.tmp_dir!(), @file_dir_name)
85 | 
86 |   defp ensure_dir do
87 |     case File.mkdir(dir()) do
88 |       :ok -> :ok
89 |       {:error, :eexist} -> :ok
90 |       error -> error
91 |     end
92 |   end
93 | end
94 | 


--------------------------------------------------------------------------------
/lib/chore_runner/dsl.ex:
--------------------------------------------------------------------------------
  1 | defmodule ChoreRunner.DSL do
  2 |   @moduledoc """
  3 |   Macros which enable the chore DSL
  4 |   """
  5 | 
  6 |   def parse_result_handler(nil), do: & &1
  7 | 
  8 |   def parse_result_handler({:fn, _, _} = fun) do
  9 |     Macro.escape(fun)
 10 |   end
 11 | 
 12 |   def parse_result_handler(handler) when is_function(handler, 1) do
 13 |     handler
 14 |   end
 15 | 
 16 |   def parse_result_handler({m, f, a}) do
 17 |     if function_exported?(m, f, a) do
 18 |       fn chore -> apply(m, f, [chore]) end
 19 |     else
 20 |       raise "Function not exported for {#{m}, #{f}, #{a}}"
 21 |     end
 22 |   end
 23 | 
 24 |   def parse_result_handler(handler) do
 25 |     raise "result_handler must be an anonymous function, function capture, MFA of a single arity function, or nil. Got: #{inspect(handler)}"
 26 |   end
 27 | 
 28 |   def using(opts) do
 29 |     quote do
 30 |       alias ChoreRunner.Chore
 31 |       @behaviour Chore
 32 | 
 33 |       import ChoreRunner.Reporter,
 34 |         only: [
 35 |           report_failed: 1,
 36 |           report_failed: 2,
 37 |           log: 1,
 38 |           log: 2,
 39 |           set_counter: 2,
 40 |           set_counter: 3,
 41 |           inc_counter: 2,
 42 |           inc_counter: 3,
 43 |           get_reporter: 0
 44 |         ]
 45 | 
 46 |       import ChoreRunner.Input,
 47 |         only: [
 48 |           string: 2,
 49 |           int: 2,
 50 |           float: 2,
 51 |           file: 2,
 52 |           bool: 2,
 53 |           string: 1,
 54 |           int: 1,
 55 |           float: 1,
 56 |           file: 1,
 57 |           bool: 1
 58 |         ]
 59 | 
 60 |       def create_download(filename, opts) do
 61 |         opts = Keyword.put_new_lazy(opts, :chore_id, fn -> Process.get(:chore_id) end)
 62 | 
 63 |         filename
 64 |         |> ChoreRunner.Downloads.create_download(opts)
 65 |         |> tap(fn
 66 |           {:ok, download} ->
 67 |             ChoreRunner.Reporter.register_download(download)
 68 | 
 69 |             case Process.get(:chore_pubsub) do
 70 |               nil ->
 71 |                 :noop
 72 | 
 73 |               pubsub ->
 74 |                 Phoenix.PubSub.broadcast(
 75 |                   pubsub,
 76 |                   ChoreRunner.downloads_pubsub_topic(),
 77 |                   :downloads_updated
 78 |                 )
 79 |             end
 80 | 
 81 |           _ ->
 82 |             :noop
 83 |         end)
 84 |       end
 85 | 
 86 |       def restriction, do: :self
 87 |       def inputs, do: []
 88 | 
 89 |       def validate_input(input),
 90 |         do: Chore.validate_input(%Chore{mod: __MODULE__}, input)
 91 | 
 92 |       def result_handler(chore) do
 93 |         result_handler = unquote(__MODULE__).parse_result_handler(unquote(opts)[:result_handler])
 94 |         result_handler.(chore)
 95 |       end
 96 | 
 97 |       defoverridable inputs: 0, restriction: 0, result_handler: 1
 98 |     end
 99 |   end
100 | end
101 | 


--------------------------------------------------------------------------------
/lib/chore_runner/input.ex:
--------------------------------------------------------------------------------
 1 | defmodule ChoreRunner.Input do
 2 |   @valid_types ~w(string int float file bool)a
 3 | 
 4 |   @type input_type :: :string | :int | :float | :file | :bool
 5 |   @type reason :: atom() | String.t()
 6 |   @type validator_function ::
 7 |           (term() -> {:ok, term()} | :ok | true | {:error, reason} | nil | false)
 8 |   @type input_options :: [
 9 |           validators: [validator_function],
10 |           description: String.t()
11 |         ]
12 |   @type t :: {input_type, atom, input_options}
13 | 
14 |   defguard valid_type(type) when type in @valid_types
15 | 
16 |   for type <- @valid_types do
17 |     @spec unquote(type)(atom(), input_options) :: t
18 |     def unquote(type)(name, opts \\ []) do
19 |       {unquote(type), name, opts}
20 |     end
21 |   end
22 | 
23 |   def types, do: @valid_types
24 | 
25 |   def validate_field(type, value) when valid_type(type) do
26 |     do_validate(type, do_cast(value, type))
27 |   end
28 | 
29 |   defp do_cast(value, :string), do: to_string(value)
30 | 
31 |   defp do_cast(value, :int) when is_binary(value) do
32 |     case Integer.parse(value) do
33 |       {int, _} -> int
34 |       _ -> value
35 |     end
36 |   end
37 | 
38 |   defp do_cast(value, :float) when is_binary(value) do
39 |     case Float.parse(value) do
40 |       {float, _} -> float
41 |       _ -> value
42 |     end
43 |   end
44 | 
45 |   defp do_cast(value, :bool) when is_binary(value) do
46 |     case String.downcase(value) do
47 |       "true" -> true
48 |       "false" -> false
49 |       _ -> value
50 |     end
51 |   end
52 | 
53 |   defp do_cast(value, :int) when is_integer(value), do: value
54 |   defp do_cast(value, :float) when is_float(value), do: value
55 |   defp do_cast(value, :bool) when is_boolean(value), do: value
56 |   defp do_cast(value, _), do: value
57 | 
58 |   defp do_validate(:string, value) when is_binary(value), do: {:ok, value}
59 |   defp do_validate(:int, value) when is_integer(value), do: {:ok, value}
60 |   defp do_validate(:float, value) when is_float(value), do: {:ok, value}
61 |   defp do_validate(:bool, value) when is_boolean(value), do: {:ok, value}
62 |   defp do_validate(:file, %module{} = value) when module == Plug.Upload, do: {:ok, value}
63 | 
64 |   defp do_validate(:file, path) when is_binary(path) do
65 |     if File.exists?(path), do: {:ok, path}, else: {:error, :does_not_exist}
66 |   end
67 | 
68 |   defp do_validate(_, _), do: {:error, :invalid}
69 | end
70 | 


--------------------------------------------------------------------------------
/lib/chore_runner/reporter.ex:
--------------------------------------------------------------------------------
  1 | defmodule ChoreRunner.Reporter do
  2 |   use GenServer
  3 |   require Logger
  4 |   alias ChoreRunner.{Chore, ChoreSupervisor}
  5 | 
  6 |   @reporter_pid_dict_key :chore_reporter_pid
  7 |   @pubsub_dict_key :chore_pubsub
  8 |   @chore_id_dict_key :chore_id
  9 |   def __process_dict_key__, do: @reporter_pid_dict_key
 10 | 
 11 |   def init({opts, chore}) do
 12 |     emit_telemetry(:init, %{chore: chore, opts: opts})
 13 |     pubsub = Keyword.get(opts, :pubsub)
 14 |     finished_function = Keyword.get(opts, :result_handler, & &1)
 15 | 
 16 |     unless pubsub do
 17 |       Logger.warning(":pubsub option not supplied to `ChoreRunner.Reporter`")
 18 |     end
 19 | 
 20 |     send(self(), :broadcast)
 21 | 
 22 |     {:ok,
 23 |      %{
 24 |        chore: Map.put(chore, :reporter, self()),
 25 |        last_sent_chore: chore,
 26 |        pubsub: pubsub,
 27 |        finished_function: finished_function
 28 |      }}
 29 |   end
 30 | 
 31 |   # def start_link(init_opts, opts \\ [])
 32 | 
 33 |   def start_link(init_opts, opts) do
 34 |     merged_opts = Keyword.merge(init_opts, opts)
 35 |     chore = Keyword.fetch!(merged_opts, :chore)
 36 |     GenServer.start_link(__MODULE__, {merged_opts, chore}, name: name(chore))
 37 |   end
 38 | 
 39 |   defp report_started,
 40 |     do: GenServer.cast(get_reporter_pid(), {:chore_started, DateTime.utc_now()})
 41 | 
 42 |   defp report_finished(result),
 43 |     do: GenServer.cast(get_reporter_pid(), {:chore_finished, DateTime.utc_now(), result})
 44 | 
 45 |   def report_failed(reporter \\ nil, reason),
 46 |     do:
 47 |       GenServer.cast(reporter || get_reporter_pid(), {:chore_failed, reason, DateTime.utc_now()})
 48 | 
 49 |   def log(reporter \\ nil, message),
 50 |     do: GenServer.cast(reporter || get_reporter_pid(), {:log, message, DateTime.utc_now()})
 51 | 
 52 |   def register_download(reporter \\ nil, download),
 53 |     do: GenServer.cast(reporter || get_reporter_pid(), {:register_download, download})
 54 | 
 55 |   def set_counter(reporter \\ nil, name, value),
 56 |     do: do_update_counter(reporter, name, value, :set)
 57 | 
 58 |   def inc_counter(reporter \\ nil, name, amount),
 59 |     do: do_update_counter(reporter, name, amount, :inc)
 60 | 
 61 |   defp do_update_counter(reporter, name, value, operation),
 62 |     do: GenServer.cast(reporter || get_reporter_pid(), {:update_counter, name, value, operation})
 63 | 
 64 |   def get_chore_state(%Chore{} = chore) do
 65 |     GenServer.call(name(chore), :chore_state)
 66 |   end
 67 | 
 68 |   def get_reporter, do: get_reporter_pid()
 69 | 
 70 |   def handle_call(:chore_state, _from, %{chore: chore} = state), do: {:reply, chore, state}
 71 | 
 72 |   def handle_call(
 73 |         {:start_chore_task, input, _opts},
 74 |         _from,
 75 |         %{chore: %Chore{id: id, mod: chore_mod, task: nil} = chore} = state
 76 |       ) do
 77 |     reporter_pid = self()
 78 | 
 79 |     task =
 80 |       Task.Supervisor.async_nolink(ChoreSupervisor, fn ->
 81 |         set_up_process_dict(id, reporter_pid, state.pubsub)
 82 | 
 83 |         lock_arg =
 84 |           case chore_mod.restriction() do
 85 |             :none -> :none
 86 |             :self -> chore_mod
 87 |             :global -> :global
 88 |           end
 89 | 
 90 |         if try_lock(lock_arg) do
 91 |           report_started()
 92 |           result = chore_mod.run(input)
 93 |           report_finished(result)
 94 |         else
 95 |           report_failed("Failed to acquire lock")
 96 |         end
 97 |       end)
 98 | 
 99 |     new_chore = %Chore{chore | task: task}
100 |     {:reply, new_chore, %{state | chore: new_chore}}
101 |   end
102 | 
103 |   def handle_call(:stop_chore, _from, state) do
104 |     ChoreSupervisor
105 |     |> Task.Supervisor.terminate_child(state.chore.task.pid)
106 |     |> case do
107 |       :ok ->
108 |         new_state =
109 |           %{state | chore: put_log(state.chore, "Stopping Chore", DateTime.utc_now())}
110 |           |> fail_chore("Stopped", DateTime.utc_now())
111 | 
112 |         state.finished_function.(new_state.chore)
113 | 
114 |         Task.async(fn ->
115 |           Process.sleep(10)
116 |           DynamicSupervisor.terminate_child(ChoreRunner.ReporterSupervisor, self())
117 |         end)
118 | 
119 |         {:reply, :ok, new_state}
120 | 
121 |       _ ->
122 |         {:reply, :error, state}
123 |     end
124 |     |> tap(fn {_, status, state} ->
125 |       emit_telemetry(:stop_chore, %{status: status, state: state})
126 |     end)
127 |   end
128 | 
129 |   def handle_cast({:chore_started, timestamp}, state) do
130 |     new_state = put_in(state.chore.started_at, timestamp)
131 |     emit_telemetry(:start_chore, %{state: new_state})
132 |     broadcast(new_state.pubsub, new_state.chore, :chore_started)
133 |     {:noreply, new_state}
134 |   end
135 | 
136 |   def handle_cast({:chore_finished, timestamp, result}, state) do
137 |     new_state = %{state | chore: %{state.chore | finished_at: timestamp, result: result}}
138 |     emit_telemetry(:chore_finished, %{chore: %{state.chore | result: nil}})
139 |     broadcast(new_state.pubsub, new_state.chore, :chore_finished)
140 |     state.finished_function.(new_state.chore)
141 |     {:noreply, new_state}
142 |   end
143 | 
144 |   def handle_cast({:chore_failed, reason, timestamp}, state) do
145 |     new_state = fail_chore(state, reason, timestamp)
146 |     {:noreply, new_state}
147 |   end
148 | 
149 |   def handle_cast({:log, message, timestamp}, state) do
150 |     %{state | chore: put_log(state.chore, message, timestamp)}
151 |     |> tap(&emit_telemetry(:log, %{state: &1}))
152 |     |> then(&{:noreply, &1})
153 |   end
154 | 
155 |   def handle_cast({:register_download, download}, state) do
156 |     state.chore.downloads
157 |     |> put_in([download | state.chore.downloads])
158 |     |> tap(&emit_telemetry(:register_download, %{state: &1}))
159 |     |> then(&{:noreply, &1})
160 |   end
161 | 
162 |   def handle_cast({:update_counter, name, value, operation}, state) when is_number(value) do
163 |     state.chore.values[name]
164 |     |> update_in(&do_update_values(&1, value, operation))
165 |     |> tap(&emit_telemetry(:update_counter, %{state: &1}))
166 |     |> then(&{:noreply, &1})
167 |   end
168 | 
169 |   defp fail_chore(state, reason, timestamp) do
170 |     new_state = put_in(state.chore.finished_at, timestamp)
171 | 
172 |     new_state = %{
173 |       new_state
174 |       | chore: put_log(new_state.chore, "Failed with reason: #{reason}", timestamp)
175 |     }
176 | 
177 |     emit_telemetry(:chore_failed, %{state: new_state, error_reason: reason})
178 |     broadcast(new_state.pubsub, new_state.chore, :chore_failed)
179 |     new_state
180 |   end
181 | 
182 |   def handle_info(:broadcast, %{pubsub: nil} = state), do: {:noreply, state}
183 | 
184 |   def handle_info(:broadcast, %{chore: %{finished_at: finished_at}} = state)
185 |       when not is_nil(finished_at),
186 |       do: {:noreply, state}
187 | 
188 |   def handle_info(:broadcast, %{chore: chore, last_sent_chore: last_sent_chore} = state) do
189 |     Process.send_after(self(), :broadcast, 10)
190 | 
191 |     if chore == last_sent_chore do
192 |       {:noreply, state}
193 |     else
194 |       broadcast(state.pubsub, diff_chore(last_sent_chore, chore), :chore_update)
195 | 
196 |       {:noreply, %{state | last_sent_chore: chore}}
197 |     end
198 |   end
199 | 
200 |   def handle_info({ref, result}, %{chore: %{task: %{ref: ref}}} = state),
201 |     do: {:noreply, put_in(state.chore.result, result)}
202 | 
203 |   def handle_info({:DOWN, ref, _, _, {error, trace}}, %{chore: %{task: %{ref: ref}}} = state) do
204 |     {:stop, :normal,
205 |      fail_chore(
206 |        state,
207 |        "Failed due to error:\n#{inspect(error)}\n#{inspect(trace)}",
208 |        DateTime.utc_now()
209 |      )}
210 |   end
211 | 
212 |   def handle_info({:DOWN, ref, _, _, _}, %{chore: %{task: %{ref: ref}}} = state),
213 |     do: {:stop, :normal, state}
214 | 
215 |   defp diff_chore(prev, current) do
216 |     %Chore{current | logs: current.logs -- prev.logs}
217 |   end
218 | 
219 |   defp do_update_values(nil, value, operation), do: do_update_values(0, value, operation)
220 |   defp do_update_values(original, value, :inc), do: original + value
221 |   defp do_update_values(_original, value, :set), do: value
222 | 
223 |   defp put_log(%Chore{logs: logs} = chore, log, timestamp),
224 |     do: %Chore{chore | logs: logs ++ [{log, timestamp}]}
225 | 
226 |   defp set_up_process_dict(chore_id, reporter_pid, pubsub) do
227 |     Process.put(@chore_id_dict_key, chore_id)
228 |     Process.put(@reporter_pid_dict_key, reporter_pid)
229 |     Process.put(@pubsub_dict_key, pubsub)
230 |   end
231 | 
232 |   defp get_reporter_pid do
233 |     case Process.get(@reporter_pid_dict_key) do
234 |       nil ->
235 |         :"$callers"
236 |         |> Process.get()
237 |         |> Enum.find(fn pid ->
238 |           Process.info(pid, :dictionary)[@reporter_pid_dict_key]
239 |         end)
240 |         |> case do
241 |           nil -> raise "Attempted to call a chore reporting function outside of a chore"
242 |           pid -> pid
243 |         end
244 | 
245 |       pid ->
246 |         pid
247 |     end
248 |   end
249 | 
250 |   defp try_lock(:none), do: true
251 |   defp try_lock(lock_type), do: :global.set_lock(lock_id(lock_type), all_nodes(), 0)
252 | 
253 |   defp lock_id(:global), do: {__MODULE__, self()}
254 |   defp lock_id(chore_mod), do: {chore_mod, self()}
255 | 
256 |   defp all_nodes, do: [node() | Node.list()]
257 | 
258 |   defp name(%Chore{id: id}), do: {:global, {__MODULE__, id}}
259 | 
260 |   defp broadcast(nil, _, _), do: :noop
261 | 
262 |   defp broadcast(pubsub, chore, key) do
263 |     Phoenix.PubSub.broadcast(
264 |       pubsub,
265 |       ChoreRunner.chore_pubsub_topic(:all),
266 |       {key, chore}
267 |     )
268 | 
269 |     Phoenix.PubSub.broadcast(
270 |       pubsub,
271 |       ChoreRunner.chore_pubsub_topic(chore),
272 |       {key, chore}
273 |     )
274 |   end
275 | 
276 |   events = [
277 |     :chore_failed,
278 |     :chore_finished,
279 |     :init,
280 |     :log,
281 |     :register_download,
282 |     :start_chore,
283 |     :stop_chore,
284 |     :update_counter
285 |   ]
286 | 
287 |   defp emit_telemetry(event, meta, measurements \\ %{})
288 | 
289 |   for event <- events do
290 |     defp emit_telemetry(unquote(event), meta, measurements) do
291 |       [:chore_runner, :reporter, unquote(event)]
292 |       |> :telemetry.execute(measurements, meta)
293 |     end
294 |   end
295 | end
296 | 


--------------------------------------------------------------------------------
/lib/chore_runner/reporter_supervisor.ex:
--------------------------------------------------------------------------------
 1 | defmodule ChoreRunner.ReporterSupervisor do
 2 |   use DynamicSupervisor
 3 | 
 4 |   def start_link(opts) do
 5 |     DynamicSupervisor.start_link(__MODULE__, opts, name: __MODULE__)
 6 |   end
 7 | 
 8 |   @impl true
 9 |   def init(opts) do
10 |     DynamicSupervisor.init(strategy: :one_for_one, extra_arguments: opts)
11 |   end
12 | end
13 | 


--------------------------------------------------------------------------------
/lib/chore_runner/supervisor.ex:
--------------------------------------------------------------------------------
 1 | defmodule ChoreRunner.Supervisor do
 2 |   @moduledoc false
 3 | 
 4 |   def start_link(opts) do
 5 |     children = [
 6 |       %{id: :pg, start: {:pg, :start_link, [ChoreRunner]}},
 7 |       {Task.Supervisor, name: ChoreRunner.ChoreSupervisor},
 8 |       {ChoreRunner.ReporterSupervisor, [opts]}
 9 |     ]
10 | 
11 |     sup_opts = [strategy: :one_for_one, name: ChoreRunner.Supervisor]
12 |     Supervisor.start_link(children, sup_opts)
13 |   end
14 | end
15 | 


--------------------------------------------------------------------------------
/lib/chore_runner_ui.ex:
--------------------------------------------------------------------------------
 1 | defmodule ChoreRunnerUI do
 2 |   @moduledoc false
 3 |   @pubsub_topic "chore_live_ui:*"
 4 |   def view do
 5 |     quote do
 6 |       use Phoenix.View,
 7 |         root: "lib/chore_runner_ui/templates",
 8 |         namespace: ChoreRunnerUI
 9 | 
10 |       import Phoenix.Controller,
11 |         only: [get_flash: 1, get_flash: 2, view_module: 1, view_template: 1]
12 | 
13 |       import Phoenix.Component
14 |       unquote(view_helpers())
15 |     end
16 |   end
17 | 
18 |   def live do
19 |     quote do
20 |       use Phoenix.LiveView,
21 |         layout: {ChoreRunnerUI.ChoreView, :live}
22 | 
23 |       unquote(view_helpers())
24 |     end
25 |   end
26 | 
27 |   def live_component do
28 |     quote do
29 |       use Phoenix.LiveComponent
30 | 
31 |       unquote(view_helpers())
32 |     end
33 |   end
34 | 
35 |   defp view_helpers do
36 |     quote do
37 |       import Phoenix.HTML
38 |       import Phoenix.HTML.Form
39 |       use PhoenixHTMLHelpers
40 | 
41 |       import Phoenix.LiveView.Helpers
42 | 
43 |       import Phoenix.View
44 |     end
45 |   end
46 | 
47 |   defmacro __using__(which) when is_atom(which) do
48 |     apply(__MODULE__, which, [])
49 |   end
50 | 
51 |   def pubsub_topic, do: @pubsub_topic
52 | end
53 | 


--------------------------------------------------------------------------------
/lib/chore_runner_ui/chore_live.ex:
--------------------------------------------------------------------------------
  1 | defmodule ChoreRunnerUI.ChoreLive do
  2 |   @moduledoc """
  3 |   A LiveView used in conjunction with ChoreRunner's regular functionality.
  4 |   Features logging and data value display of all running chores locally and on all connected nodes.
  5 |   Allows the running of chores (with autogenerated forms based on chore inputs), as well as
  6 |   stopping running chores.
  7 | 
  8 |   ## Usage
  9 |   Make sure that `Chore.Supervisor` is added in your application
 10 |   ```
 11 |   children = [
 12 |     {Phoenix.PubSub, name: MyApp.PubSub},
 13 |     {ChoreRunner, pubsub: MyApp.PubSub}
 14 |   ]
 15 |   ```
 16 |   A pubsub MUST BE RUNNING and configured for both the Chore supervisor and the Chore LiveView for the Chore UI to function.
 17 | 
 18 |   Make the Chore LiveView accessible in your Phoenix web app by modifying the router.
 19 | 
 20 |   ### Router
 21 |   ```
 22 |   @chore_session %{
 23 |     "otp_app" => :my_app,
 24 |     "chore_root" => MyApp.Chores,
 25 |     "pubsub" => MyApp.PubSub
 26 |   }
 27 |   scope "/" do
 28 |     pipe_through :browser
 29 | 
 30 |     live_session :chores, session: @chore_session do
 31 |       live "/", ChoreRunnerUI.ChoreLive, :index
 32 |     end
 33 |   end
 34 |   ```
 35 | 
 36 |   The `"chore_root"` key in the session should be the module root that all of your chore modules use.
 37 |   For example: if your root is `MyApp.Chores` your chore modules should be named like `MyApp.Chores.MyChore`
 38 | 
 39 |   Now you can visit the speficied url and start running chores!
 40 |   """
 41 |   use ChoreRunnerUI, :live
 42 |   alias ChoreRunnerUI.ChoreView
 43 |   require Logger
 44 | 
 45 |   @impl true
 46 |   def mount(params, session, socket) do
 47 |     subscribe_to_pubsub(session)
 48 |     chores = list_chores(session)
 49 | 
 50 |     socket =
 51 |       assign(socket,
 52 |         chores: chores,
 53 |         form_chores: Enum.sort(Map.keys(chores)),
 54 |         running_chores: ChoreRunner.list_running_chores(),
 55 |         params: params,
 56 |         session: session,
 57 |         inputs: [],
 58 |         file_inputs: [],
 59 |         selected_chore: nil,
 60 |         filter_string: ""
 61 |       )
 62 |       |> set_inputs(nil)
 63 | 
 64 |     {:ok, socket}
 65 |   end
 66 | 
 67 |   @impl true
 68 |   def handle_params(params, url, %{assigns: %{chores: chores}} = socket) do
 69 |     chore_name = Map.get(params, "chore") || Map.keys(chores) |> List.first()
 70 |     selected_chore = chores[chore_name]
 71 | 
 72 |     if selected_chore do
 73 |       socket =
 74 |         socket
 75 |         |> assign(
 76 |           download_plug_path: Map.get(params, :download_plug_path, "/chores/download"),
 77 |           download_live_path: Map.get(params, :download_live_path, "/chores/downloads"),
 78 |           currently_selected_chore: selected_chore,
 79 |           chore_name: chore_name,
 80 |           chore_errors: %{},
 81 |           is_chore_valid: true,
 82 |           uri: URI.parse(url)
 83 |         )
 84 |         |> set_inputs(selected_chore.inputs())
 85 | 
 86 |       {:noreply, socket}
 87 |     else
 88 |       socket =
 89 |         socket
 90 |         |> assign(
 91 |           currently_selected_chore: nil,
 92 |           chore_name: nil,
 93 |           chore_errors: %{},
 94 |           is_chore_valid: false,
 95 |           uri: URI.parse(url)
 96 |         )
 97 | 
 98 |       {:noreply, socket}
 99 |     end
100 |   end
101 | 
102 |   @impl true
103 |   def render(assigns) do
104 |     ChoreView.render("index.html", assigns)
105 |   end
106 | 
107 |   def handle_event(
108 |         "filter_form_changed",
109 |         %{"filter_chores" => %{"filter_string" => filter_string}},
110 |         %{
111 |           assigns: %{chores: chores}
112 |         } = socket
113 |       ) do
114 |     filter_string = String.downcase(filter_string)
115 | 
116 |     form_chores =
117 |       chores
118 |       |> Map.keys()
119 |       |> Enum.sort()
120 |       |> Enum.filter(&(&1 |> String.downcase() |> String.contains?(filter_string)))
121 | 
122 |     {:noreply, assign(socket, form_chores: form_chores, filter_string: filter_string)}
123 |   end
124 | 
125 |   def handle_event(
126 |         "form_changed",
127 |         %{"run_chore" => %{"chore" => chore_name} = attrs},
128 |         %{
129 |           assigns: %{uri: uri, chores: chores, currently_selected_chore: currently_selected_chore}
130 |         } = socket
131 |       ) do
132 |     selected_chore = chores[chore_name]
133 | 
134 |     if(currently_selected_chore == selected_chore) do
135 |       chore_attrs = Map.get(attrs, "chore_attrs", %{})
136 | 
137 |       errors =
138 |         case selected_chore.validate_input(chore_attrs) do
139 |           {:ok, _} -> []
140 |           {:error, errors} -> errors
141 |         end
142 | 
143 |       {:noreply, assign_errors(socket, errors)}
144 |     else
145 |       # [SRC](https://elixirforum.com/t/liveview-push-patch-append-to-params/30964/9)
146 |       to = uri.path <> "?" <> URI.encode_query(%{chore: chore_name})
147 | 
148 |       {:noreply, push_patch(socket, to: to)}
149 |     end
150 |   end
151 | 
152 |   @impl true
153 |   def handle_event("run_chore", %{"run_chore" => %{"chore" => chore_name} = attrs}, socket) do
154 |     file_attrs =
155 |       Enum.map(socket.assigns.file_inputs, fn file_input ->
156 |         uploaded_file =
157 |           consume_uploaded_entries(socket, file_input, fn %{path: path}, _entry ->
158 |             tmp_dir = System.tmp_dir!()
159 |             File.mkdir(Path.join(tmp_dir, "chore_files"))
160 |             dest = Path.join([System.tmp_dir!(), "chore_files", Path.basename(path)])
161 |             File.cp!(path, dest)
162 |             dest
163 |           end)
164 |           |> List.first()
165 | 
166 |         {file_input, uploaded_file}
167 |       end)
168 |       |> Enum.into(%{})
169 | 
170 |     chore = socket.assigns.chores[chore_name]
171 |     chore_attrs = Map.get(attrs, "chore_attrs", %{}) |> Map.merge(file_attrs)
172 | 
173 |     extra_data = socket.assigns.session["extra_data"]
174 | 
175 |     errors =
176 |       case ChoreRunner.run_chore(chore, chore_attrs, extra_data: extra_data) do
177 |         {:ok, _} -> []
178 |         {:error, errors} -> errors
179 |       end
180 | 
181 |     {:noreply, assign_errors(socket, errors)}
182 |   end
183 | 
184 |   @impl true
185 |   def handle_event("stop_chore", _, %{assigns: %{running_chores: []}} = socket),
186 |     do: {:noreply, socket}
187 | 
188 |   @impl true
189 |   def handle_event("stop_chore", %{"id" => id}, %{assigns: %{running_chores: chores}} = socket) do
190 |     chores
191 |     |> Enum.find(&(&1.id == id))
192 |     |> ChoreRunner.stop_chore()
193 | 
194 |     {:noreply, socket}
195 |   end
196 | 
197 |   @impl true
198 |   def handle_event("dismiss_chore", %{"id" => id}, socket) do
199 |     {:noreply, remove_running_chore(socket, id)}
200 |   end
201 | 
202 |   @impl true
203 |   def handle_event("select_chore", %{"chore" => id}, socket) do
204 |     selected_chore = Enum.find(socket.assigns.running_chores, &(&1.id == id))
205 |     {:noreply, assign(socket, :selected_chore, selected_chore)}
206 |   end
207 | 
208 |   @impl true
209 |   def handle_event("deselect_chore", _, socket) do
210 |     {:noreply, assign(socket, :selected_chore, nil)}
211 |   end
212 | 
213 |   @impl true
214 |   def handle_event(event, _attrs, socket) do
215 |     Logger.debug("Unhandled event #{inspect(event)} in ChoreRunnerUI.ChoreLive")
216 |     {:noreply, socket}
217 |   end
218 | 
219 |   @impl true
220 |   def handle_info({:chore_started, chore}, socket) do
221 |     {:noreply,
222 |      assign(
223 |        socket,
224 |        :running_chores,
225 |        [chore | socket.assigns.running_chores]
226 |      )}
227 |   end
228 | 
229 |   def handle_info({:chore_update, chore}, socket) do
230 |     socket =
231 |       if socket.assigns.selected_chore && socket.assigns.selected_chore.id == chore.id do
232 |         assign(
233 |           socket,
234 |           :selected_chore,
235 |           %{
236 |             socket.assigns.selected_chore
237 |             | logs: chore.logs ++ socket.assigns.selected_chore.logs
238 |           }
239 |         )
240 |       else
241 |         socket
242 |       end
243 | 
244 |     {:noreply,
245 |      assign(
246 |        socket,
247 |        :running_chores,
248 |        update_running_chore(socket.assigns.running_chores, chore)
249 |      )}
250 |   end
251 | 
252 |   def handle_info({final_message, chore}, socket)
253 |       when final_message in [:chore_finished, :chore_failed] do
254 |     {:noreply,
255 |      assign(
256 |        socket,
257 |        :running_chores,
258 |        update_running_chore(socket.assigns.running_chores, chore)
259 |      )}
260 |   end
261 | 
262 |   def handle_info(unhandled, socket) do
263 |     Logger.debug("Unhandled message #{inspect(unhandled)} sent to ChoreRunnerUI.ChoreLive")
264 |     {:noreply, socket}
265 |   end
266 | 
267 |   defp subscribe_to_pubsub(%{"pubsub" => pubsub}) do
268 |     Phoenix.PubSub.subscribe(pubsub, ChoreRunner.chore_pubsub_topic(:all))
269 |   end
270 | 
271 |   defp subscribe_to_pubsub(_), do: :noop
272 | 
273 |   defp list_chores(%{"otp_app" => app, "chore_root" => root}) do
274 |     split_root = Module.split(root) |> Enum.reverse()
275 | 
276 |     {:ok, modules} = :application.get_key(app, :modules)
277 | 
278 |     modules
279 |     |> Enum.map(fn module ->
280 |       module
281 |       |> Module.split()
282 |       |> Enum.reverse()
283 |       |> case do
284 |         [trimmed_module | ^split_root] ->
285 |           {trimmed_module, module}
286 | 
287 |         _ ->
288 |           nil
289 |       end
290 |     end)
291 |     |> Enum.reject(&is_nil/1)
292 |     |> Enum.into(%{})
293 |   end
294 | 
295 |   defp list_chores(_), do: %{}
296 | 
297 |   defp update_running_chore(running_chores, %{id: id} = chore) do
298 |     Enum.map(running_chores, fn
299 |       %{id: ^id, logs: logs, finished_at: nil} ->
300 |         %{chore | logs: chore.logs ++ logs, task: chore.task}
301 | 
302 |       chore ->
303 |         chore
304 |     end)
305 |   end
306 | 
307 |   defp remove_running_chore(%{assigns: %{running_chores: running_chores}} = socket, id) do
308 |     assign(socket, :running_chores, Enum.reject(running_chores, &(&1.id == id)))
309 |   end
310 | 
311 |   defp set_inputs(socket, nil), do: socket
312 | 
313 |   defp set_inputs(socket, inputs) do
314 |     socket
315 |     |> disable_previous_file_inputs()
316 |     |> assign(inputs: inputs)
317 |     |> assign(
318 |       :file_inputs,
319 |       inputs |> Enum.filter(&(elem(&1, 0) == :file)) |> Enum.map(&elem(&1, 1))
320 |     )
321 |     |> enable_file_inputs()
322 |   end
323 | 
324 |   defp disable_previous_file_inputs(%{assigns: %{inputs: nil}} = socket), do: socket
325 | 
326 |   defp disable_previous_file_inputs(%{assigns: %{inputs: inputs}} = socket) do
327 |     inputs
328 |     |> Enum.filter(fn {type, _key, _opts} -> type == :file end)
329 |     |> Enum.reduce(socket, fn {:file, key, _opts}, socket ->
330 |       disallow_upload(socket, key)
331 |     end)
332 |   end
333 | 
334 |   defp enable_file_inputs(%{assigns: %{inputs: nil}} = socket), do: socket
335 | 
336 |   defp enable_file_inputs(%{assigns: %{inputs: inputs}} = socket) do
337 |     inputs
338 |     |> Enum.filter(fn {type, _key, _opts} -> type == :file end)
339 |     |> Enum.reduce(socket, fn {:file, key, _opts}, socket ->
340 |       allow_upload(socket, key, accept: :any, max_entries: 1)
341 |     end)
342 |   end
343 | 
344 |   defp assign_errors(socket, []) do
345 |     assign(socket, chore_errors: %{}, is_chore_valid: true)
346 |   end
347 | 
348 |   defp assign_errors(socket, errors) do
349 |     assign(socket, chore_errors: Enum.into(errors, %{}), is_chore_valid: false)
350 |   end
351 | end
352 | 


--------------------------------------------------------------------------------
/lib/chore_runner_ui/chore_view.ex:
--------------------------------------------------------------------------------
 1 | defmodule ChoreRunnerUI.ChoreView do
 2 |   use ChoreRunnerUI, :view
 3 |   alias ChoreRunnerUI.Components.{ChoreItemComponent, ChoreModalComponent}
 4 |   @styles File.read!(Application.app_dir(:chore_runner, "priv/css/main.css"))
 5 | 
 6 |   defp styles, do: @styles
 7 | 
 8 |   defp first_log([{log, ts} | _]) do
 9 |     "[#{ts}] #{log}"
10 |   end
11 | 
12 |   defp first_log(_), do: ""
13 | 
14 |   defp download_link(download_plug_path, download),
15 |     do:
16 |       ChoreRunner.Downloads.StorageService.file_url(download,
17 |         download_plug_path: download_plug_path
18 |       )
19 | end
20 | 


--------------------------------------------------------------------------------
/lib/chore_runner_ui/components/chore_item_components.ex:
--------------------------------------------------------------------------------
1 | defmodule ChoreRunnerUI.Components.ChoreItemComponent do
2 |   use Phoenix.LiveComponent
3 |   alias ChoreRunnerUI.ChoreView
4 | 
5 |   def render(assigns) do
6 |     ChoreView.render("chore_item.html", assigns)
7 |   end
8 | end
9 | 


--------------------------------------------------------------------------------
/lib/chore_runner_ui/components/chore_modal_component.ex:
--------------------------------------------------------------------------------
 1 | defmodule ChoreRunnerUI.Components.ChoreModalComponent do
 2 |   use Phoenix.LiveComponent
 3 | 
 4 |   def render(assigns) do
 5 |     ~H"""
 6 |     <div>
 7 |       <%= if @chore do %>
 8 |         <div class="chore-modal-backdrop" phx-click="deselect_chore">
 9 |         </div>
10 |         <div class="chore-modal-container" id={"#{@chore.id}-modal"}>
11 |           <div class="chore-modal-header">
12 |             <h2><%= @chore.__struct__%></h2>
13 |             <button phx-click="deselect_chore"> X</button>
14 |           </div>
15 |           <div class="chore-modal-text-container">
16 |             <%= for {message, timestamp} <- @chore.logs do %>
17 |               <p id={"#{@chore.id}-#{timestamp}"}><%= timestamp %> <%= message %></p>
18 |             <% end %>
19 |           </div>
20 |           <div class="chore-modal-bottom-container">
21 |             <button phx-click="deselect_chore">Close</button>
22 |           </div>
23 |         </div>
24 |       <% end %>
25 |     </div>
26 |     """
27 |   end
28 | end
29 | 


--------------------------------------------------------------------------------
/lib/chore_runner_ui/downloads_live.ex:
--------------------------------------------------------------------------------
 1 | defmodule ChoreRunnerUI.DownloadsLive do
 2 |   @moduledoc """
 3 |   A LiveView used in conjunction with ChoreRunner's regular functionality.
 4 |   Allows viewing and downloading of files generated by Chores.
 5 | 
 6 |   ## Usage
 7 |   Make sure that `Chore.Supervisor` is added in your application
 8 |   ```
 9 |   children = [
10 |     {Phoenix.PubSub, name: MyApp.PubSub},
11 |     {ChoreRunner, pubsub: MyApp.PubSub}
12 |   ]
13 |   ```
14 |   A pubsub MUST BE RUNNING and configured for both the Chore supervisor and the ChoreRunner LiveViews for the Downloads UI to function.
15 | 
16 |   Make the Downloads LiveView and downloadable files accessible in your Phoenix web app by modifying the router.
17 | 
18 |   ### Router
19 |   ```
20 |   @chore_session %{
21 |     "otp_app" => :my_app,
22 |     "chore_root" => MyApp.Chores,
23 |     "pubsub" => MyApp.PubSub
24 |   }
25 |   scope "/" do
26 |     pipe_through :browser
27 | 
28 |     live_session :chores, session: @chore_session do
29 |       live "/", ChoreRunnerUI.ChoreLive, :index
30 |       live "/", ChoreRunnerUI.DownloadsLive, :index
31 |     end
32 | 
33 |     forward "/chore_downloads", ChoreRunnerUI.DownloadsPlug
34 |   end
35 |   ```
36 | 
37 |   The `"chore_root"` key in the session should be the module root that all of your chore modules use.
38 |   For example: if your root is `MyApp.Chores` your chore modules should be named like `MyApp.Chores.MyChore`
39 | 
40 |   Now you can visit the speficied url and start running chores!
41 |   """
42 |   use ChoreRunnerUI, :live
43 |   alias Phoenix.PubSub
44 |   alias ChoreRunner.Downloads
45 |   alias ChoreRunner.Downloads.StorageService
46 |   require Logger
47 | 
48 |   @impl true
49 |   def mount(params, session, socket) do
50 |     socket =
51 |       assign(socket,
52 |         pubsub: subscribe_to_pubsub(session),
53 |         download_plug_path: Map.get(params, :download_plug_path, "/chores/download"),
54 |         chore_live_path: Map.get(params, :chore_live_path, "/chores")
55 |       )
56 |       |> refresh_downloads()
57 | 
58 |     {:ok, socket}
59 |   end
60 | 
61 |   @impl true
62 |   def handle_event("delete", %{"id" => id}, socket) do
63 |     with %{} = download <- StorageService.find_file(id) do
64 |       Downloads.delete_download(download)
65 |     end
66 | 
67 |     PubSub.broadcast(
68 |       socket.assigns.pubsub,
69 |       ChoreRunner.downloads_pubsub_topic(),
70 |       :downloads_updated
71 |     )
72 | 
73 |     {:noreply, refresh_downloads(socket)}
74 |   end
75 | 
76 |   @impl true
77 |   def handle_info(:downloads_updated, socket) do
78 |     {:noreply, refresh_downloads(socket)}
79 |   end
80 | 
81 |   defp refresh_downloads(socket), do: assign(socket, downloads: Downloads.list_downloads())
82 | 
83 |   defp subscribe_to_pubsub(%{"pubsub" => pubsub}) do
84 |     Process.put(:chore_pubsub, pubsub)
85 |     PubSub.subscribe(pubsub, ChoreRunner.downloads_pubsub_topic())
86 |     pubsub
87 |   end
88 | 
89 |   defp download_link(download_plug_path, download),
90 |     do:
91 |       ChoreRunner.Downloads.StorageService.file_url(download,
92 |         download_plug_path: download_plug_path
93 |       )
94 | end
95 | 


--------------------------------------------------------------------------------
/lib/chore_runner_ui/downloads_live.html.heex:
--------------------------------------------------------------------------------
 1 | <div class="running-chores-container">
 2 |   <ul class="running-chores">
 3 |     <div class="flex-row-between">
 4 |     <h1 class="downloads-header">File Downloads</h1>
 5 |     <a href={@chore_live_path} class="link-button file-button">
 6 |       Back to chores
 7 |     </a>
 8 |     </div>
 9 |     <%= for download <- @downloads do %>
10 |     <li class="running-chore" id={download.id}>
11 |       <div class="chore-item">
12 |         <div class="download-name">
13 |           <span><%= download.name %></span>
14 |           <div>
15 |           <a class="link-button file-button" href={download_link(@download_plug_path, download)} download>
16 |             Download
17 |           </a>
18 |           <a class="link-button file-button file-button-delete" href="#" phx-click="delete" phx-value-id={download.id}>
19 |             Delete
20 |           </a>
21 |           </div>
22 |         </div>
23 |       </div>
24 |     </li>
25 |     <% end %>
26 |   </ul>
27 | </div>
28 | 


--------------------------------------------------------------------------------
/lib/chore_runner_ui/downloads_plug.ex:
--------------------------------------------------------------------------------
 1 | defmodule ChoreRunnerUI.DownloadsPlug do
 2 |   import Plug.Conn
 3 |   alias ChoreRunner.Downloads.StorageService
 4 |   @buffer_size 1024
 5 | 
 6 |   def init(opts), do: opts
 7 | 
 8 |   def call(%{path_info: [id]} = conn, _) do
 9 |     current_node = node()
10 | 
11 |     case StorageService.find_file(id) do
12 |       nil ->
13 |         send_resp(conn, 404, "Not Found")
14 | 
15 |       %{path: path, node: ^current_node, name: name} ->
16 |         # file exists on current node
17 | 
18 |         # Put correct disposition for named downloads
19 |         conn
20 |         |> put_resp_header("content-disposition", "attachment; filename=\"#{name}\"")
21 |         |> send_file(200, path)
22 | 
23 |       %{node: _other_node, name: name} = file ->
24 |         conn
25 |         |> put_resp_header("content-disposition", "attachment; filename=\"#{name}\"")
26 |         |> remote_send_chunked_file(file)
27 |     end
28 |   end
29 | 
30 |   defp remote_send_chunked_file(conn, file) do
31 |     pid = self()
32 |     ref = make_ref()
33 |     # Open file on remote node
34 |     :rpc.cast(file.node, __MODULE__, :safely_open_remote_file, [file.path, pid, ref])
35 | 
36 |     # Receive file device pid, and rpc pid linked to device pid
37 |     {remote_pid_linked_to_opened_file, opened_file} =
38 |       receive do
39 |         {:open, remote_pid_linked_to_opened_file, opened_file, ^ref} ->
40 |           {remote_pid_linked_to_opened_file, opened_file}
41 |       end
42 | 
43 |     # Build binary stream that reads file from remote node, sending a heartbeat to rpc pid while reading
44 | 
45 |     file_stream =
46 |       opened_file
47 |       |> IO.binstream(@buffer_size)
48 |       |> Stream.each(fn _ ->
49 |         send(remote_pid_linked_to_opened_file, {:heartbeat, ref})
50 |       end)
51 | 
52 |     # Set up http headers. setting the "content-length" header will cause cowboy to treat this as a streamed response instead of a chunked response
53 |     chunked_conn =
54 |       conn
55 |       |> put_resp_header("Content-Transfer-Encoding", "binary")
56 |       |> put_resp_header("content-length", to_string(file.size))
57 |       |> put_resp_content_type(file.type)
58 |       |> send_chunked(200)
59 | 
60 |     # Send chunked file from remote node
61 |     conn =
62 |       Enum.reduce(file_stream, chunked_conn, fn file_chunk, conn ->
63 |         case chunk(conn, file_chunk) do
64 |           {:ok, conn} ->
65 |             conn
66 | 
67 |           {:error, _reason} ->
68 |             conn
69 |         end
70 |       end)
71 | 
72 |     # Inform rpc pid it can safely end, this closes the file as well
73 |     send(remote_pid_linked_to_opened_file, {:done, ref})
74 |     conn
75 |   end
76 | 
77 |   @doc false
78 |   def safely_open_remote_file(path, remote_casting_pid, ref) do
79 |     opened_file = File.open!(path)
80 |     send(remote_casting_pid, {:open, self(), opened_file, ref})
81 |     wait_for_send_completion(ref)
82 |     File.close(opened_file)
83 |   end
84 | 
85 |   defp wait_for_send_completion(ref) do
86 |     receive do
87 |       {:heartbeat, ^ref} ->
88 |         wait_for_send_completion(ref)
89 | 
90 |       {:done, ^ref} ->
91 |         :done
92 |     after
93 |       10000 ->
94 |         :timeout
95 |     end
96 |   end
97 | end
98 | 


--------------------------------------------------------------------------------
/lib/chore_runner_ui/templates/chore/chore_input_errors.html.leex:
--------------------------------------------------------------------------------
1 | <div class="chore-form-input-errors-wrapper">
2 |   <%= for error <- Map.get(@chore_errors, @key, []) do %>
3 |     <p class="alert alert-danger"><%= inspect(error) %></p>
4 |   <% end %>
5 | </div>
6 | 


--------------------------------------------------------------------------------
/lib/chore_runner_ui/templates/chore/chore_inputs.html.heex:
--------------------------------------------------------------------------------
 1 | <%= case @type do %>
 2 |   <% :bool -> %>
 3 |     <div class="chore-form-input-wrapper chore-form-top-level-input-wrapper">
 4 |       <%= label @form, @key, class: "chore-form-label" %>
 5 |       <%= checkbox @form, @key, class: "chore-form-input chore-form-checkbox", phx_update: "ignore" %>
 6 |       <%= render(__MODULE__, "chore_input_errors.html", chore_errors: @chore_errors, key: @key) %>
 7 |     </div>
 8 |   <% :string -> %>
 9 |     <div class="chore-form-input-wrapper chore-form-top-level-input-wrapper">
10 |       <%= label @form, @key, class: "chore-form-label" %>
11 |       <%= text_input @form, @key, class: "chore-form-input chore-form-text-input", phx_update: "ignore" %>
12 |       <%= render(__MODULE__, "chore_input_errors.html", chore_errors: @chore_errors, key: @key) %>
13 |     </div>
14 |   <% type when type in [:int, :float] -> %>
15 |     <div class="chore-form-input-wrapper chore-form-top-level-input-wrapper">
16 |       <%= label @form, @key, class: "chore-form-label" %>
17 |       <%= number_input @form, @key, class: "chore-form-input chore-form-text-input chore-form-number-input", phx_update: "ignore" %>
18 |       <%= render(__MODULE__, "chore_input_errors.html", chore_errors: @chore_errors, key: @key) %>
19 |     </div>
20 |   <% :file -> %>
21 |     <div class="chore-form-file-input-wrapper chore-form-top-level-input-wrapper" phx-drop-target={Map.get(@uploads, @key).ref}>
22 |       <div class="chore-form-input-wrapper">
23 |         <%= label @form, @key, class: "chore-form-label" %>
24 |         <.live_file_input upload={Map.get(@uploads, @key)} class="chore-form-input chore-form-file-input" />
25 |       </div>
26 |       <%= render(__MODULE__, "chore_input_errors.html", chore_errors: @chore_errors, key: @key) %>
27 |       <%= for entry <- Map.get(@uploads, @key).entries do %>
28 |         <progress value={entry.progress} max="100"> <%= entry.progress %>% </progress>
29 |         <!--button phx-click="cancel-upload" phx-value-ref="<%#= entry.ref %>" aria-label="cancel">&times;</button-->
30 |         <%= for error <- upload_errors(Map.get(@uploads, @key), entry) do %>
31 |           <p class="alert alert-danger"><%= inspect(error) %></p>
32 |         <% end %>
33 |       <% end %>
34 |     </div>
35 |   <% _ -> %>
36 |     What was this supposed to be?
37 | <% end %>
38 | 


--------------------------------------------------------------------------------
/lib/chore_runner_ui/templates/chore/chore_item.html.heex:
--------------------------------------------------------------------------------
 1 | <div class="chore-item" phx-click="select_chore" phx-value-chore={@chore.id}>
 2 |   <div class="chore-item-name">
 3 |     <span><%= @chore.mod %></span>
 4 |     <%= if @chore.finished_at do %>
 5 |     <button class="chore-item-stop-button" phx-click="dismiss_chore" phx-value-id={@chore.id}>
 6 |       Dismiss
 7 |     </button>
 8 |     <% else %>
 9 |     <button class="chore-item-stop-button" phx-click="stop_chore" phx-value-id={@chore.id}>
10 |       Stop
11 |     </button>
12 |     <% end %>
13 |   </div>
14 |   <div class="chore-item-content-container">
15 |     <div class="chore-item-recentlog">
16 |       <%= first_log(@chore.logs) %>
17 |       <div>Additional logs hidden -- Click to view!</div>
18 |     </div>
19 |     <div class="chore-item-stats">
20 |       <%= for {key, val} <- @chore.values do %>
21 |       <div class="chore-item-stats-scalar">
22 |         <span><%= key %></span>
23 |         <span><%= val %></span>
24 |       </div>
25 |       <% end %>
26 |     </div>
27 |   </div>
28 |   <div class="chore-downloads">
29 |     <%= case List.first(@chore.downloads) do %>
30 |       <% nil -> %>
31 |       <% download -> %>
32 |       <a href={download_link(@download_plug_path, download)} download>
33 |       <%= download.name %>
34 |       </a>
35 |       <%= if(length(@chore.downloads) > 1) do %>
36 |         <a href={@download_live_path}> see more </a>
37 |       <% end %>
38 |     <% end %>
39 |   </div>
40 | </div>
41 | 


--------------------------------------------------------------------------------
/lib/chore_runner_ui/templates/chore/index.html.heex:
--------------------------------------------------------------------------------
 1 | <div class="chore-menu">
 2 |   <h2 class="my-chores-heading">My Chores</h2>
 3 |   <.form :let={f} for={%{}} as={:filter_chores} phx-change="filter_form_changed">
 4 |     <div class="chore-form-flexbox">
 5 |       <%= text_input f, :filter_string, value: @filter_string, class: "chore-form-select", placeholder: "Filter chores" %>
 6 |     </div>
 7 |   </.form>
 8 |   <.form :let={f} for={%{}} as={:run_chore} phx-submit="run_chore" phx-change="form_changed">
 9 |     <div class="chore-form-flexbox">
10 |       <%= select f, :chore, @form_chores, prompt: [key: "Choose your chore"], selected: @chore_name, class: "chore-form-select", promt: "Select a Chore" %>
11 |       <%= if @currently_selected_chore do %>
12 |         <div class="chore-inputs-container">
13 |           <div class="chore-form-inputs-flexbox">
14 |             <.inputs_for :let={ff} field={f[:chore_attrs]}>
15 |               <%= for {type, key, opts} <- @inputs do %>
16 |                 <%= render(__MODULE__, "chore_inputs.html", Map.merge(assigns, %{type: type, key: key, form: ff, opts: opts})) %>
17 |               <% end %>
18 |             </.inputs_for>
19 |           </div>
20 |           <%= submit "Run Chore", class: "chore-run-submit-button", disabled: not @is_chore_valid %>
21 |         </div>
22 |       <% end %>
23 |     </div>
24 |   </.form>
25 | </div>
26 | <div class="running-chores-container">
27 |   <ul class="running-chores">
28 |     <%= for chore <- @running_chores do %>
29 |     <li class="running-chore" id={chore.id}>
30 |       <.live_component id={"#{chore.id}-items"} module={ChoreItemComponent} chore={chore} download_live_path={@download_live_path} download_plug_path={@download_plug_path}/>
31 |     </li>
32 |     <% end %>
33 |   </ul>
34 | </div>
35 | <.live_component id="chore-modal" module={ChoreModalComponent} chore={@selected_chore} />
36 | 


--------------------------------------------------------------------------------
/lib/chore_runner_ui/templates/chore/live.html.leex:
--------------------------------------------------------------------------------
1 | <style>
2 |  <%= styles() %>
3 | </style>
4 | <div role="main" class="chore-container">
5 |   <%= @inner_content %>
6 | </div>
7 | 


--------------------------------------------------------------------------------
/lib/example.ex:
--------------------------------------------------------------------------------
 1 | defmodule ApiV1.Chores.Example do
 2 |   use ChoreRunner.Chore
 3 |   alias ChoreRunner.Reporter
 4 | 
 5 |   def inputs do
 6 |     [string(:str, [])]
 7 |   end
 8 | 
 9 |   def restriction, do: :none
10 | 
11 |   def run(%{str: _str}) do
12 |     Reporter.log("Starting")
13 |     Process.sleep(100_000)
14 | 
15 |     Enum.each(1..100, fn n ->
16 |       Process.sleep(10)
17 |       set_counter(:percent_done, n)
18 |     end)
19 | 
20 |     Reporter.log("Wrapping up")
21 | 
22 |     {:ok, :done}
23 |   end
24 | end
25 | 


--------------------------------------------------------------------------------
/mix.exs:
--------------------------------------------------------------------------------
 1 | defmodule ChoreRunner.MixProject do
 2 |   @moduledoc false
 3 | 
 4 |   use Mix.Project
 5 | 
 6 |   def project do
 7 |     [
 8 |       app: :chore_runner,
 9 |       version: "0.5.4",
10 |       elixir: "~> 1.12",
11 |       start_permanent: Mix.env() == :prod,
12 |       deps: deps(),
13 |       elixirc_paths: elixirc_paths(Mix.env()),
14 |       package: package(),
15 |       description: """
16 |       An Elixir library for writing and running code chores.
17 |       """,
18 |       aliases: aliases()
19 |     ]
20 |   end
21 | 
22 |   defp elixirc_paths(:test), do: ["lib", "test/support"]
23 |   defp elixirc_paths(_), do: ["lib"]
24 | 
25 |   def application do
26 |     [
27 |       extra_applications: [:logger]
28 |     ]
29 |   end
30 | 
31 |   defp deps do
32 |     [
33 |       {:ex_doc, ">= 0.0.0", only: :dev, runtime: false},
34 |       {:floki, ">= 0.30.0", only: :test},
35 |       {:phoenix_live_view, "~> 1.0"},
36 |       {:phoenix_view, "~> 2.0"},
37 |       {:phoenix_html, "~> 4.0"},
38 |       {:phoenix_html_helpers, "~> 1.0"},
39 |       {:telemetry, "~> 1.1"}
40 |     ]
41 |   end
42 | 
43 |   defp package do
44 |     [
45 |       maintainers: ["Chris Freeze"],
46 |       licenses: ["Apache 2.0"],
47 |       links: %{github: "https://github.com/pepsico-ecommerce/chore_runner"},
48 |       files: ~w(lib priv/css mix.exs README.md CHANGELOG.md .formatter.exs)
49 |     ]
50 |   end
51 | 
52 |   defp aliases do
53 |     [publish: ["hex.publish", &git_tag/1]]
54 |   end
55 | 
56 |   defp git_tag(_args) do
57 |     System.cmd("git", ["tag", "v" <> Mix.Project.config()[:version]])
58 |     System.cmd("git", ["push", "--tags"])
59 |   end
60 | end
61 | 


--------------------------------------------------------------------------------
/mix.lock:
--------------------------------------------------------------------------------
 1 | %{
 2 |   "castore": {:hex, :castore, "1.0.11", "4bbd584741601eb658007339ea730b082cc61f3554cf2e8f39bf693a11b49073", [:mix], [], "hexpm", "e03990b4db988df56262852f20de0f659871c35154691427a5047f4967a16a62"},
 3 |   "earmark_parser": {:hex, :earmark_parser, "1.4.42", "f23d856f41919f17cd06a493923a722d87a2d684f143a1e663c04a2b93100682", [:mix], [], "hexpm", "6915b6ca369b5f7346636a2f41c6a6d78b5af419d61a611079189233358b8b8b"},
 4 |   "ex_doc": {:hex, :ex_doc, "0.36.1", "4197d034f93e0b89ec79fac56e226107824adcce8d2dd0a26f5ed3a95efc36b1", [:mix], [{:earmark_parser, "~> 1.4.42", [hex: :earmark_parser, repo: "hexpm", optional: false]}, {:makeup_c, ">= 0.1.0", [hex: :makeup_c, repo: "hexpm", optional: true]}, {:makeup_elixir, "~> 0.14 or ~> 1.0", [hex: :makeup_elixir, repo: "hexpm", optional: false]}, {:makeup_erlang, "~> 0.1 or ~> 1.0", [hex: :makeup_erlang, repo: "hexpm", optional: false]}, {:makeup_html, ">= 0.1.0", [hex: :makeup_html, repo: "hexpm", optional: true]}], "hexpm", "d7d26a7cf965dacadcd48f9fa7b5953d7d0cfa3b44fa7a65514427da44eafd89"},
 5 |   "floki": {:hex, :floki, "0.37.0", "b83e0280bbc6372f2a403b2848013650b16640cd2470aea6701f0632223d719e", [:mix], [], "hexpm", "516a0c15a69f78c47dc8e0b9b3724b29608aa6619379f91b1ffa47109b5d0dd3"},
 6 |   "html_entities": {:hex, :html_entities, "0.5.2", "9e47e70598da7de2a9ff6af8758399251db6dbb7eebe2b013f2bbd2515895c3c", [:mix], [], "hexpm", "c53ba390403485615623b9531e97696f076ed415e8d8058b1dbaa28181f4fdcc"},
 7 |   "jason": {:hex, :jason, "1.2.2", "ba43e3f2709fd1aa1dce90aaabfd039d000469c05c56f0b8e31978e03fa39052", [:mix], [{:decimal, "~> 1.0 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm", "18a228f5f0058ee183f29f9eae0805c6e59d61c3b006760668d8d18ff0d12179"},
 8 |   "makeup": {:hex, :makeup, "1.2.1", "e90ac1c65589ef354378def3ba19d401e739ee7ee06fb47f94c687016e3713d1", [:mix], [{:nimble_parsec, "~> 1.4", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "d36484867b0bae0fea568d10131197a4c2e47056a6fbe84922bf6ba71c8d17ce"},
 9 |   "makeup_elixir": {:hex, :makeup_elixir, "1.0.1", "e928a4f984e795e41e3abd27bfc09f51db16ab8ba1aebdba2b3a575437efafc2", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}, {:nimble_parsec, "~> 1.2.3 or ~> 1.3", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "7284900d412a3e5cfd97fdaed4f5ed389b8f2b4cb49efc0eb3bd10e2febf9507"},
10 |   "makeup_erlang": {:hex, :makeup_erlang, "1.0.1", "c7f58c120b2b5aa5fd80d540a89fdf866ed42f1f3994e4fe189abebeab610839", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}], "hexpm", "8a89a1eeccc2d798d6ea15496a6e4870b75e014d1af514b1b71fa33134f57814"},
11 |   "mime": {:hex, :mime, "2.0.6", "8f18486773d9b15f95f4f4f1e39b710045fa1de891fada4516559967276e4dc2", [:mix], [], "hexpm", "c9945363a6b26d747389aac3643f8e0e09d30499a138ad64fe8fd1d13d9b153e"},
12 |   "nimble_parsec": {:hex, :nimble_parsec, "1.4.2", "8efba0122db06df95bfaa78f791344a89352ba04baedd3849593bfce4d0dc1c6", [:mix], [], "hexpm", "4b21398942dda052b403bbe1da991ccd03a053668d147d53fb8c4e0efe09c973"},
13 |   "phoenix": {:hex, :phoenix, "1.7.18", "5310c21443514be44ed93c422e15870aef254cf1b3619e4f91538e7529d2b2e4", [:mix], [{:castore, ">= 0.0.0", [hex: :castore, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix_pubsub, "~> 2.1", [hex: :phoenix_pubsub, repo: "hexpm", optional: false]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}, {:phoenix_view, "~> 2.0", [hex: :phoenix_view, repo: "hexpm", optional: true]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.7", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:plug_crypto, "~> 1.2 or ~> 2.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}, {:websock_adapter, "~> 0.5.3", [hex: :websock_adapter, repo: "hexpm", optional: false]}], "hexpm", "1797fcc82108442a66f2c77a643a62980f342bfeb63d6c9a515ab8294870004e"},
14 |   "phoenix_html": {:hex, :phoenix_html, "4.2.0", "83a4d351b66f472ebcce242e4ae48af1b781866f00ef0eb34c15030d4e2069ac", [:mix], [], "hexpm", "9713b3f238d07043583a94296cc4bbdceacd3b3a6c74667f4df13971e7866ec8"},
15 |   "phoenix_html_helpers": {:hex, :phoenix_html_helpers, "1.0.1", "7eed85c52eff80a179391036931791ee5d2f713d76a81d0d2c6ebafe1e11e5ec", [:mix], [{:phoenix_html, "~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: false]}, {:plug, "~> 1.5", [hex: :plug, repo: "hexpm", optional: true]}], "hexpm", "cffd2385d1fa4f78b04432df69ab8da63dc5cf63e07b713a4dcf36a3740e3090"},
16 |   "phoenix_live_view": {:hex, :phoenix_live_view, "1.0.2", "e7b1dd68c86326e2c45cc81da41e332cc8aa7228a7161e2c811dcd7f1dd14db1", [:mix], [{:floki, "~> 0.36", [hex: :floki, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix, "~> 1.6.15 or ~> 1.7.0", [hex: :phoenix, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 3.3 or ~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: false]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}, {:phoenix_view, "~> 2.0", [hex: :phoenix_view, repo: "hexpm", optional: true]}, {:plug, "~> 1.15", [hex: :plug, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.2 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "8a40265b0cd7d3a35f136dfa3cc048e3b198fc3718763411a78c323a44ebebee"},
17 |   "phoenix_pubsub": {:hex, :phoenix_pubsub, "2.1.3", "3168d78ba41835aecad272d5e8cd51aa87a7ac9eb836eabc42f6e57538e3731d", [:mix], [], "hexpm", "bba06bc1dcfd8cb086759f0edc94a8ba2bc8896d5331a1e2c2902bf8e36ee502"},
18 |   "phoenix_template": {:hex, :phoenix_template, "1.0.4", "e2092c132f3b5e5b2d49c96695342eb36d0ed514c5b252a77048d5969330d639", [:mix], [{:phoenix_html, "~> 2.14.2 or ~> 3.0 or ~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}], "hexpm", "2c0c81f0e5c6753faf5cca2f229c9709919aba34fab866d3bc05060c9c444206"},
19 |   "phoenix_view": {:hex, :phoenix_view, "2.0.4", "b45c9d9cf15b3a1af5fb555c674b525391b6a1fe975f040fb4d913397b31abf4", [:mix], [{:phoenix_html, "~> 2.14.2 or ~> 3.0 or ~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}], "hexpm", "4e992022ce14f31fe57335db27a28154afcc94e9983266835bb3040243eb620b"},
20 |   "plug": {:hex, :plug, "1.16.1", "40c74619c12f82736d2214557dedec2e9762029b2438d6d175c5074c933edc9d", [:mix], [{:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_crypto, "~> 1.1.1 or ~> 1.2 or ~> 2.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.3 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "a13ff6b9006b03d7e33874945b2755253841b238c34071ed85b0e86057f8cddc"},
21 |   "plug_crypto": {:hex, :plug_crypto, "2.1.0", "f44309c2b06d249c27c8d3f65cfe08158ade08418cf540fd4f72d4d6863abb7b", [:mix], [], "hexpm", "131216a4b030b8f8ce0f26038bc4421ae60e4bb95c5cf5395e1421437824c4fa"},
22 |   "telemetry": {:hex, :telemetry, "1.3.0", "fedebbae410d715cf8e7062c96a1ef32ec22e764197f70cda73d82778d61e7a2", [:rebar3], [], "hexpm", "7015fc8919dbe63764f4b4b87a95b7c0996bd539e0d499be6ec9d7f3875b79e6"},
23 |   "websock": {:hex, :websock, "0.5.3", "2f69a6ebe810328555b6fe5c831a851f485e303a7c8ce6c5f675abeb20ebdadc", [:mix], [], "hexpm", "6105453d7fac22c712ad66fab1d45abdf049868f253cf719b625151460b8b453"},
24 |   "websock_adapter": {:hex, :websock_adapter, "0.5.8", "3b97dc94e407e2d1fc666b2fb9acf6be81a1798a2602294aac000260a7c4a47d", [:mix], [{:bandit, ">= 0.6.0", [hex: :bandit, repo: "hexpm", optional: true]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.6", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:websock, "~> 0.5", [hex: :websock, repo: "hexpm", optional: false]}], "hexpm", "315b9a1865552212b5f35140ad194e67ce31af45bcee443d4ecb96b5fd3f3782"},
25 | }
26 | 


--------------------------------------------------------------------------------
/priv/css/chore.css:
--------------------------------------------------------------------------------
  1 | button {
  2 |   background: transparent;
  3 |   box-shadow: 0px 0px 0px transparent;
  4 |   border: 0px solid transparent;
  5 |   text-shadow: 0px 0px 0px transparent;
  6 | }
  7 | 
  8 | button:hover {
  9 |   background: transparent;
 10 |   box-shadow: 0px 0px 0px transparent;
 11 |   border: 0px solid transparent;
 12 |   text-shadow: 0px 0px 0px transparent;
 13 | }
 14 | 
 15 | button:active {
 16 |   outline: none;
 17 |   border: none;
 18 | }
 19 | 
 20 | button:focus {
 21 |   outline: 0;
 22 | }
 23 | 
 24 | .chore-container {
 25 |   width: 100%;
 26 |   height: 100%;
 27 | }
 28 | 
 29 | .running-chores {
 30 |   list-style-type: none;
 31 |   background-color: white;
 32 |   border-bottom-left-radius: 0.5em;
 33 |   border-bottom-right-radius: 0.5em;
 34 |   padding: 0.25em;
 35 |   padding-top: 0.5em;
 36 |   box-shadow: 1px 2px rgba(128, 128, 128, 0.432) inset;
 37 |   height: 40em;
 38 |   overflow-y: scroll;
 39 |   margin-top: 0;
 40 | }
 41 | 
 42 | .chore-menu {
 43 |   background-color: blue;
 44 |   width: 100%;
 45 |   min-height: 10em;
 46 |   margin-top: 0.25em;
 47 |   border-top-left-radius: 0.5em;
 48 |   border-top-right-radius: 0.5em;
 49 | 
 50 | }
 51 | 
 52 | .chore-form-flexbox {
 53 |   display: flex;
 54 |   flex-direction: column;
 55 |   justify-content: space-between;
 56 |   min-height: 5em;
 57 |   padding: 1em;
 58 | }
 59 | 
 60 | .chore-form-select {
 61 |   height: 2em;
 62 |   margin-bottom: 1em;
 63 | }
 64 | 
 65 | .chore-form-flexbox {
 66 |   display: flex;
 67 |   flex-direction: column;
 68 | }
 69 | 
 70 | .chore-form-inputs-flexbox {
 71 |   text-align: left;
 72 |   display: flex;
 73 |   flex-direction: row;
 74 |   flex-wrap: wrap;
 75 |   justify-content: space-between;
 76 | }
 77 | 
 78 | .chore-form-file-input-wrapper {
 79 |   display: flex;
 80 |   flex-direction: column;
 81 |   justify-content: center;
 82 |   align-items: stretch;
 83 | }
 84 | 
 85 | .chore-form-top-level-input-wrapper {
 86 |   width: 32%;
 87 |   min-height: 3em;
 88 | }
 89 | 
 90 | .chore-form-input-errors-wrapper{
 91 |   display: flex;
 92 |   flex-direction: column;
 93 |   justify-content: center;
 94 |   align-items: center;
 95 | }
 96 | 
 97 | .chore-form-input-wrapper {
 98 |   padding-left: 0.25em;
 99 |   padding-right: 0.25em;
100 |   display: flex;
101 |   justify-content: space-between;
102 |   align-items: center;
103 | }
104 | 
105 | .chore-form-label {
106 |   color: white;
107 | }
108 | 
109 | .chore-form-file-input {
110 |   color: white;
111 | }
112 | 
113 | .chore-run-submit-button {
114 |   color: white;
115 |   border: 1px solid white;
116 |   border-radius: 1em;
117 |   padding-left: 0.5em;
118 |   padding-right: 0.5em;
119 |   padding-top: 0.25em;
120 |   padding-bottom: 0.25em;
121 |   align-self: flex-end;
122 | }
123 | 
124 | .chore-run-submit-button:hover{
125 |   border: 2px solid white;
126 |   margin-top: -1px;
127 |   margin-right: -1px;
128 | }
129 | 
130 | .chore-run-submit-button:active{
131 |   color: blue;
132 |   background-color: white;
133 |   border: 2px solid white;
134 |   margin-top: -1px;
135 |   margin-right: -1px;
136 | }
137 | 
138 | .chore-item {
139 |   margin-bottom: 0.1em;
140 |   min-height: 5em;
141 |   border-radius: 1em;
142 |   background-color: white;
143 |   padding-left: 2em;
144 |   padding-right: 2em;
145 |   font-size: 100%;
146 |   font-weight: bold;
147 |   border: 1px solid rgba(233, 233, 233, 0.432);
148 |   box-shadow: 2px 2px rgba(128, 128, 128, 0.432);
149 |   display: flex;
150 |   flex-direction: row;
151 |   align-items: center;
152 |   justify-content: space-between;
153 | }
154 | 
155 | .chore-item-recentlog {
156 |   font-family: Courier New, monospace;
157 |   padding-left: 0.5em;
158 |   padding-right: 0.5em;
159 |   height: 4em;
160 |   width: 20em;
161 |   overflow-wrap: normal;
162 |   background-color: black;
163 |   color: white;
164 |   box-shadow: 1px 2px rgba(128, 128, 128, 0.432) inset;
165 |   text-align: left;
166 | }
167 | 
168 | .chore-item-stats {
169 |   width: 3em;
170 |   display: flex;
171 |   flex-wrap: nowrap;
172 |   flex-direction: row;
173 |   justify-content: space-between;
174 | }
175 | 
176 | .chore-item-stats>div {
177 |   width: 2em;
178 |   text-align: center;
179 |   display: flex;
180 |   flex-direction: row;
181 |   align-items: center;
182 | }
183 | 
184 | .chore-item-stop-button {
185 |   border: 1px solid black;
186 |   border-radius: 1em;
187 |   padding: 0.5em;
188 | }


--------------------------------------------------------------------------------
/priv/css/main.css:
--------------------------------------------------------------------------------
1 | @import url(https://fonts.googleapis.com/css?family=Source+Sans+Pro:300,400,600,700,800,900&display=swap);
2 | button{background:#023e73;color:#fff;border-radius:4px;padding:6px 15px 6px 15px;font-family:"Source Sans Pro","Helvetica Neue","Helvetica","Arial",sans-serif}.file-button{background:#023e73;color:#fff;border-radius:4px;padding:6px 15px 6px 15px;font-family:"Source Sans Pro","Helvetica Neue","Helvetica","Arial",sans-serif;cursor:pointer}.file-button-delete{background:#730202;margin-left:2em}.chore-container{width:100%;height:100vh;max-width:100vw !important;margin:0;display:flex;justify-content:flex-start}.chore-menu{background-color:#f0f0f0;padding:10px 20px;min-width:250px}.running-chores-container{flex:1}.my-chores-heading{color:#262626;font-size:24px;margin-bottom:20px;font-family:"Source Sans Pro","Helvetica Neue","Helvetica","Arial",sans-serif}.chore-form-flexbox{display:flex;flex-direction:column;justify-content:space-between;min-height:5em}.chore-form-select{margin-bottom:1em;color:#595959;border:1px solid #d9d9d9;border-radius:4px;padding:9px 15px}.chore-form-label{color:#262626;font-size:12px;font-family:Source Sans Pro;font-weight:700;margin-bottom:8px}.chore-form-input-wrapper{display:flex;flex-direction:column;flex:1;margin-top:10px}.chore-inputs-container{padding:24px;border:1px solid #d9d9d9;border-radius:4px;background-color:#fff}.chore-form-input{border:1px solid #d9d9d9;padding:6px 12px}.chore-form-flexbox{display:flex;flex-direction:column}.chore-form-inputs-flexbox{text-align:left;display:flex;flex-direction:column}.chore-form-file-input-wrapper{display:flex;flex-direction:column;justify-content:center;align-items:stretch}.chore-form-top-level-input-wrapper{width:100%;min-height:3em}.chore-form-input-errors-wrapper{display:flex;margin-top:10px;flex-direction:column}.chore-form-file-input{color:#fff}.chore-run-submit-button{margin-top:24px;width:100%}.alert{padding:5px !important;margin-bottom:10px !important;max-width:400px}progress{width:100%}.chore-item{margin:5px 20px;margin-bottom:.1em;border:1px solid #d9d9d9;border-radius:4px;background-color:#fff;display:flex;flex-direction:column}.chore-item:first-of-type{margin-top:20px}.chore-item-name{background-color:#f0f0f0;padding:16px 24px;display:flex;justify-content:space-between;align-items:center}.chore-item-name span{text-transform:uppercase;font-family:"Source Sans Pro","Helvetica Neue","Helvetica","Arial",sans-serif;font-weight:400;color:#262626}.chore-item-content-container{display:flex}.chore-item-recentlog{font-family:Courier New,monospace;padding:20px 24px;color:#595959;width:50%}.chore-item-stats{width:50%;display:flex;flex-wrap:wrap;padding:10px 24px}.chore-item-stats-scalar{padding:5px;margin:5px;border:1px solid #d9d9d9;border-radius:4px;flex:0 0 45%;min-height:30px;display:flex;flex-direction:column}.chore-item-stats-scalar span:first-child{font-family:"Source Sans Pro","Helvetica Neue","Helvetica","Arial",sans-serif;font-size:12px;color:#828282}.chore-item-stats-scalar span:nth-child(2){font-family:"Source Sans Pro","Helvetica Neue","Helvetica","Arial",sans-serif;font-size:28px}.chore-downloads{padding:2px;padding-left:1em;padding-right:1em;background-color:#f0f0f0;border-top:1px #000}.chore-downloads a{text-decoration:underline;cursor:pointer;margin-right:1em}.chore-modal-backdrop{position:absolute;top:0;left:0;z-index:100;background-color:#000;opacity:.3;display:flex;justify-content:center;align-items:center;height:100%;width:100%}.chore-modal-container{position:absolute;top:50%;left:50%;transform:translate(-50%, -50%);z-index:101;background-color:#f9f9f9;box-shadow:1px 2px 4px rgba(0,0,0,.15);min-height:200px;min-width:50%;max-height:400px;overflow-y:scroll}.chore-modal-header{padding:10px;background-color:#f9f9f9;border-bottom:1px solid #d9d9d9;display:flex;justify-content:space-between}.chore-modal-header h2{font-weight:500;font-family:"Source Sans Pro","Helvetica Neue","Helvetica","Arial",sans-serif !important;color:#262626;font-size:16px}.chore-modal-header button{border:none;background-color:transparent;color:#000;padding:0;color:#262626;font-family:"Source Sans Pro","Helvetica Neue","Helvetica","Arial",sans-serif}.chore-modal-text-container{min-height:200px;min-width:300px;max-height:300px;padding:10px}.chore-modal-text-container p{font-family:Courier New,monospace}.chore-modal-bottom-container{padding:10px;display:flex;justify-content:flex-end;background-color:#f0f0f0;border-top:1px solid #d9d9d9}.downloads-header{font-size:2em;font-weight:bolder}.flex-row-between{margin-left:1em;margin-right:1em;display:flex;flex-direction:row;justify-content:space-between;align-items:center}.download-name{background-color:#f0f0f0;padding:16px 24px;display:flex;justify-content:space-between;align-items:center}.download-name span{font-family:"Source Sans Pro","Helvetica Neue","Helvetica","Arial",sans-serif;font-weight:400;color:#262626}.running-chores{list-style-type:none;background-color:#fff;padding:.25em;padding-top:.5em;height:40em;overflow-y:scroll;margin-top:0;height:100%}
3 | 


--------------------------------------------------------------------------------
/test/chore_test.exs:
--------------------------------------------------------------------------------
 1 | defmodule ChoreTest do
 2 |   use ExUnit.Case
 3 |   alias ChoreRunner.TestChore
 4 | 
 5 |   setup do
 6 |     pid =
 7 |       start_supervised!(%{
 8 |         id: ChoreRunner.Supervisor,
 9 |         start: {ChoreRunner.Supervisor, :start_link, [[]]}
10 |       })
11 | 
12 |     {:ok, reporter_supervisor: pid}
13 |   end
14 | 
15 |   describe "run_chore/3" do
16 |     test "Runs a chore with valid inputs" do
17 |       ref = make_ref()
18 |       pid = self()
19 | 
20 |       assert {:ok, _chore} =
21 |                ChoreRunner.run_chore(
22 |                  TestChore,
23 |                  %{
24 |                    my_string: "string",
25 |                    my_float: 4.2,
26 |                    my_file: "test/support/test_file.txt",
27 |                    sleep_length: 0,
28 |                    sleep?: false
29 |                  },
30 |                  result_handler: fn chore ->
31 |                    send(pid, {ref, chore})
32 |                  end,
33 |                  extra_data: %{foo: :bar}
34 |                )
35 | 
36 |       assert_receive {^ref, chore}
37 | 
38 |       assert %{
39 |                extra_data: %{foo: :bar},
40 |                inputs: %{
41 |                  my_file: "test/support/test_file.txt",
42 |                  my_float: 4.2,
43 |                  my_string: "string",
44 |                  sleep?: false,
45 |                  sleep_length: 0
46 |                },
47 |                logs: [_, _],
48 |                mod: ChoreRunner.TestChore,
49 |                result:
50 |                  {:ok,
51 |                   %{
52 |                     my_file: "test/support/test_file.txt",
53 |                     my_file_value: "I am a test file",
54 |                     my_float: 4.2,
55 |                     my_string: "string",
56 |                     sleep?: false,
57 |                     sleep_length: 0
58 |                   }}
59 |              } = chore
60 |     end
61 | 
62 |     test "Rejects a chore with invalid inputs" do
63 |       assert {:error, errors} =
64 |                ChoreRunner.run_chore(
65 |                  TestChore,
66 |                  %{
67 |                    my_string: :atom,
68 |                    my_float: 1,
69 |                    my_file: nil,
70 |                    sleep_length: 4.3,
71 |                    sleep?: "false"
72 |                  }
73 |                )
74 | 
75 |       assert Keyword.get(errors, :sleep_length) == [:invalid]
76 |     end
77 | 
78 |     test "Rejects a chore with a nonexistant file" do
79 |       assert {:error, errors} =
80 |                ChoreRunner.run_chore(
81 |                  TestChore,
82 |                  %{
83 |                    my_string: "string",
84 |                    my_float: 4.2,
85 |                    my_file: "test/support/bad_file.txt",
86 |                    sleep_length: 0,
87 |                    sleep?: false
88 |                  }
89 |                )
90 | 
91 |       assert Keyword.get(errors, :my_file) == [:does_not_exist]
92 |     end
93 |   end
94 | end
95 | 


--------------------------------------------------------------------------------
/test/support/test_chore.ex:
--------------------------------------------------------------------------------
 1 | defmodule ChoreRunner.TestChore do
 2 |   use ChoreRunner.Chore
 3 | 
 4 |   def inputs do
 5 |     [
 6 |       string(:my_string),
 7 |       float(:my_float),
 8 |       file(:my_file),
 9 |       int(:sleep_length),
10 |       bool(:sleep?)
11 |     ]
12 |   end
13 | 
14 |   def run(
15 |         %{
16 |           my_string: _my_string,
17 |           my_float: _my_float,
18 |           my_file: my_file,
19 |           sleep_length: sleep_length,
20 |           sleep?: sleep?
21 |         } = attrs
22 |       ) do
23 |     if sleep?, do: Process.sleep(sleep_length)
24 |     reporter = get_reporter()
25 |     log("test")
26 |     set_counter(:test, 5)
27 |     inc_counter(:test, 1)
28 | 
29 |     spawn(fn ->
30 |       log(reporter, "test from process")
31 |       set_counter(reporter, :process_test, 10)
32 |       inc_counter(reporter, :process_test, 2)
33 |     end)
34 | 
35 |     {:ok, Map.put(attrs, :my_file_value, File.read!(my_file))}
36 |   end
37 | end
38 | 


--------------------------------------------------------------------------------
/test/support/test_file.txt:
--------------------------------------------------------------------------------
1 | I am a test file


--------------------------------------------------------------------------------
/test/test_helper.exs:
--------------------------------------------------------------------------------
1 | ExUnit.start()
2 | 


--------------------------------------------------------------------------------