Compare commits
84
Commits
b2a74cbee4
..
main
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
9c89504399 | ||
|
|
383143024a | ||
|
|
c5c11fe8d3 | ||
|
|
05263fed2b | ||
|
|
6e35445090 | ||
|
|
95fcc61c4f | ||
|
|
2039d03a5e | ||
|
|
868a5d7e4f | ||
|
|
d710251a4e | ||
|
|
c78f5a4a6d | ||
|
|
889ad1c091 | ||
|
|
5f8b3cbe00 | ||
|
|
078f24e4b9 | ||
|
|
15e50322c4 | ||
|
|
617bd255ff | ||
|
|
022342af32 | ||
|
|
6caa2acafb | ||
|
|
7d5103ac90 | ||
|
|
3a6fe26d0c | ||
|
|
45277e02da | ||
|
|
87dda96e7e | ||
|
|
55855db55b | ||
|
|
8a4a5aef33 | ||
|
|
d33c2cf268 | ||
|
|
7bd0a652cb | ||
|
|
449f404464 | ||
|
|
0e5d76901d | ||
|
|
773f3b550f | ||
|
|
4664e71493 | ||
|
|
e7adb3e88b | ||
|
|
2e2960c159 | ||
|
|
627f813859 | ||
|
|
e750e0e687 | ||
|
|
63210afc7b | ||
|
|
7ec491d383 | ||
|
|
4f1277aa45 | ||
|
|
3908d5a3a6 | ||
|
|
5416e9b708 | ||
|
|
38d575d716 | ||
|
|
6bcab1a0d8 | ||
|
|
cceddad037 | ||
|
|
c75fc1a7b9 | ||
|
|
1098be227d | ||
|
|
a427acd6ed | ||
|
|
aee34f4e14 | ||
|
|
526710ef71 | ||
|
|
c2425e8fb0 | ||
|
|
a7a11e96b7 | ||
|
|
adce7c8427 | ||
|
|
9e00aeb6a2 | ||
|
|
b643fe55b1 | ||
|
|
138b62c54a | ||
|
|
889091d321 | ||
|
|
c2426dec3d | ||
|
|
ad023a1ba2 | ||
|
|
7ce994e814 | ||
|
|
fefeae6301 | ||
|
|
fcaccfdeb0 | ||
|
|
73d4255fd7 | ||
|
|
7ad36d8ccb | ||
|
|
f4c82df968 | ||
|
|
219f75c0e4 | ||
|
|
7ed846d0fc | ||
|
|
53c36a81de | ||
|
|
1bf2258167 | ||
|
|
4d8cb8dc36 | ||
|
|
1697d55ad5 | ||
|
|
bd1402ab3a | ||
|
|
c412435172 | ||
|
|
3b08988e30 | ||
|
|
44497173de | ||
|
|
894d8f8436 | ||
|
|
bd5f97f96e | ||
|
|
d6f785662b | ||
|
|
5d16bf4ade | ||
|
|
05bd609c7e | ||
|
|
4ea75beb7b | ||
|
|
96d3482af8 | ||
|
|
7fc07c1883 | ||
|
|
a7becaf2d4 | ||
|
|
9c47bbcb42 | ||
|
|
6063aafe8b | ||
|
|
fafc7111bb | ||
|
|
69cac934ec |
No files matched your search
+4
-1
@@ -4,9 +4,12 @@ dist-newstyle
|
||||
|
||||
.worktrees/
|
||||
|
||||
docs/superpowers
|
||||
docs/superpowers/plans
|
||||
|
||||
*.dat
|
||||
handlers.json
|
||||
*.hp
|
||||
*.eventlog
|
||||
*.eventlog.html
|
||||
*.rrd
|
||||
*.rrd.*bak*
|
||||
+5
-1
@@ -1,3 +1,7 @@
|
||||
creation_rules:
|
||||
- path_regex: "secrets.yaml"
|
||||
pgp: "95DBE64C2EA64D6B0E0C8C2F9DE6E04ED1918118"
|
||||
age:
|
||||
# usb-c yubikey
|
||||
- "age1yubikey1qw7m7rad6malegqypgntr7qmu97xrxxurp0c00s23263nuxnpek6w0jye60"
|
||||
# usb-a yubikey
|
||||
- "age1yubikey1qdnx7jum6k4fzenkqj8y5met9hyq6lqxrpzrl2788wr0q445vhupzuqtpk0"
|
||||
@@ -5,11 +5,17 @@
|
||||
A sidecar for Home Assistant that runs automations using arrowized functional
|
||||
reactive programming (AFRP). Haskell, built with cabal.
|
||||
|
||||
## Working style
|
||||
|
||||
- When doing any non-trivial work, always work in a worktree on a feature branch
|
||||
- Feature branches should be named as the topic of the change
|
||||
|
||||
## Code style
|
||||
|
||||
- Vertical modules: split by feature/concept, not by layer.
|
||||
- Comments are minimal. They describe the contract, not the implementation,
|
||||
and should stay stable as the implementation changes.
|
||||
- Never ever log directly to stdout via `putStr` and friends. Always use proper logging functions
|
||||
|
||||
## Build
|
||||
|
||||
@@ -24,3 +30,8 @@ reactive programming (AFRP). Haskell, built with cabal.
|
||||
|
||||
- hspec for unit tests, hedgehog for property tests.
|
||||
- Run with `nix develop -c cabal test`.
|
||||
|
||||
## Reviewing
|
||||
|
||||
Reviews are recorded in git notes under `refs/notes/review`; read the latest
|
||||
note before reviewing. See [[REVIEW.md]].
|
||||
@@ -0,0 +1,49 @@
|
||||
# Code Review Guidelines
|
||||
|
||||
|
||||
- Each MR should be focused, changing only one concept at a time
|
||||
- Keep MRs small - aim for under 500 lines of diff. There can be some wiggle room for cases that are hard to split
|
||||
- When reviewing code, check for test coverage and suggest tests if missing
|
||||
- Go through tests and think hard to see if any unit tests or group of unit tests can be replaced with a property test
|
||||
- When suggesting a property test, consider cases that the property needs to falsify and whether it needs its own generator
|
||||
- Business logic stays pure
|
||||
|
||||
## Comments
|
||||
|
||||
- Less is more
|
||||
- If there's comments for a function, verify they're proper haddock style
|
||||
- If there's comments for a function, they must only be about the contract and use instructions
|
||||
- If there's comments for implementation, they should only be for exceptional cases, cases where the reader would question why something is implemented like that
|
||||
- Comment style should follow minimalistic writing style
|
||||
|
||||
## Recording reviews
|
||||
|
||||
Reviews are stored as git notes under `refs/notes/review`, one note per
|
||||
reviewed commit. The note header carries `branch`, `round`, `verdict`
|
||||
(`approve` or `request-changes`), `previous` (sha of the last reviewed tip),
|
||||
and a findings list with stable IDs (`F1`, `F2`, ...) whose `status` is
|
||||
`open`, `resolved`, or `wontfix`. The body is free markdown prose.
|
||||
|
||||
Protocol:
|
||||
|
||||
1. Fetch prior results:
|
||||
`git fetch origin "refs/notes/review:refs/notes/review"`
|
||||
Ignore the failure on the first-ever review (origin has no notes ref yet);
|
||||
if the fetch is rejected as non-fast-forward, your local notes are ahead —
|
||||
push instead.
|
||||
2. Read the latest verdict and open findings for the branch:
|
||||
`scripts/review-note latest [branch]`
|
||||
3. Review the branch tip per this document.
|
||||
4. Write the note (header + markdown) to a file and attach it to the tip:
|
||||
`scripts/review-note write <file>`. Use `--force` only to replace a note
|
||||
on the same commit deliberately.
|
||||
5. Publish: `scripts/review-note push` (plain `git push` does not push
|
||||
notes).
|
||||
|
||||
On a re-review after fixes: new tip, new note, `round`+1, `previous` set to
|
||||
the last reviewed sha, open findings carried forward by ID, resolved ones
|
||||
marked `resolved`.
|
||||
|
||||
On a branch rename: update the note's `branch:` header to the new name and
|
||||
mention the old name in the body, so `latest <new-name>` chains and history
|
||||
stays findable.
|
||||
@@ -4,5 +4,4 @@ import qualified HomeAssistant.Runtime (defaultMain)
|
||||
|
||||
main :: IO ()
|
||||
main = do
|
||||
putStrLn "Hello, Haskell!"
|
||||
HomeAssistant.Runtime.defaultMain
|
||||
+13
-9
@@ -1,8 +1,10 @@
|
||||
{ mkDerivation, aeson, annotated-exception, async, base, bytestring
|
||||
, cereal, cereal-conduit, conduit, containers, directory, ekg-core
|
||||
, filepath, hedgehog, hspec, hspec-hedgehog, http-types, katip
|
||||
, lens, lens-aeson, lib, network, process, retry, scotty, stm, text
|
||||
, time, unordered-containers, uuid, wai, warp, websockets
|
||||
, cereal, cereal-conduit, cereal-text, conduit, containers
|
||||
, data-default, directory, ekg-core, exceptions, filepath, hedgehog
|
||||
, hspec, hspec-hedgehog, http-media, http-types, katip, lens
|
||||
, lens-aeson, lib, libsystemd-journal, lucid2, network, process
|
||||
, retry, servant, servant-server, stm, temporary, text, time
|
||||
, unliftio, unordered-containers, uuid, wai, warp, websockets
|
||||
}:
|
||||
mkDerivation {
|
||||
pname = "home-assistant-controller";
|
||||
@@ -12,15 +14,17 @@ mkDerivation {
|
||||
isExecutable = true;
|
||||
libraryHaskellDepends = [
|
||||
aeson annotated-exception async base bytestring cereal
|
||||
cereal-conduit conduit containers directory ekg-core filepath
|
||||
http-types katip lens lens-aeson network process retry scotty stm
|
||||
text time unordered-containers uuid wai warp websockets
|
||||
cereal-conduit cereal-text conduit containers data-default
|
||||
directory ekg-core exceptions filepath http-media http-types katip
|
||||
lens lens-aeson libsystemd-journal lucid2 network process retry
|
||||
servant servant-server stm text time unliftio unordered-containers
|
||||
uuid wai warp websockets
|
||||
];
|
||||
executableHaskellDepends = [ base ];
|
||||
testHaskellDepends = [
|
||||
aeson annotated-exception async base bytestring cereal containers
|
||||
directory ekg-core hedgehog hspec hspec-hedgehog katip process stm
|
||||
text time unordered-containers uuid
|
||||
data-default directory ekg-core hedgehog hspec hspec-hedgehog katip
|
||||
process servant stm temporary text time unordered-containers uuid
|
||||
];
|
||||
license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause";
|
||||
mainProgram = "home-assistant-controller";
|
||||
|
||||
@@ -0,0 +1,113 @@
|
||||
# Review notes protocol
|
||||
|
||||
Date: 2026-10-02
|
||||
Status: approved
|
||||
|
||||
## Purpose
|
||||
|
||||
Record code-review results as git notes under `refs/notes/review` so that the
|
||||
next reviewer — human or AI — can read the current verdict, see open findings
|
||||
with stable IDs, and continue from where the last review stopped. This
|
||||
replaces a CI reviewer: reviews happen locally, results travel with the
|
||||
commits they judged.
|
||||
|
||||
## Storage model
|
||||
|
||||
- One note per reviewed commit, in the `review` notes ref.
|
||||
- The tip of a reviewed branch always carries the latest verdict.
|
||||
- Re-reviewing after fixes writes a **new** note on the **new** tip commit.
|
||||
Old notes stay attached to old commits as history.
|
||||
- Each note links to the previously reviewed commit via `previous`, forming a
|
||||
walkable chain of review rounds per branch.
|
||||
- Merging to main needs no special handling: the `approve` note on the final
|
||||
tip is the record.
|
||||
|
||||
## Note format
|
||||
|
||||
Line-based header, then a blank line, then free markdown body:
|
||||
|
||||
branch: <branch name>
|
||||
round: <integer, starting at 1>
|
||||
verdict: approve | request-changes
|
||||
previous: none | <sha of previously reviewed tip>
|
||||
findings:
|
||||
- id: F<N>
|
||||
severity: blocker | major | minor
|
||||
file: <path>:<line>
|
||||
title: <one line>
|
||||
status: open | resolved | wontfix
|
||||
## Details
|
||||
|
||||
<markdown prose>
|
||||
|
||||
Rules:
|
||||
|
||||
- Finding IDs are unique within a note and carry forward across rounds: a
|
||||
finding resolved since the last note keeps its ID and moves to
|
||||
`status: resolved`; an unfixed finding keeps its ID and `status: open`.
|
||||
New findings get fresh IDs that do not collide with carried-forward ones.
|
||||
- The body is free markdown; the `## Details` heading in the example is
|
||||
illustrative, not required.
|
||||
- Headers are plain `key: value` lines so the helper script can parse them
|
||||
with sed/awk.
|
||||
|
||||
## Helper script: `scripts/review-note`
|
||||
|
||||
Bash, git plumbing only. Subcommands:
|
||||
|
||||
- `review-note show [commit]` — print the note for a commit (default: current
|
||||
tip). Exit 1 with a message on stderr if there is no note.
|
||||
- `review-note write <file>` — attach the note in `<file>` to the current tip
|
||||
commit. Refuses to replace an existing note unless `--force` is given; a
|
||||
proper re-review targets a new commit, so overwriting is always deliberate.
|
||||
Validates that `branch`, `round`, and `verdict` are present and that
|
||||
`verdict` uses the vocabulary above. No other validation.
|
||||
- `review-note latest [branch]` — print the note with the highest `round` for
|
||||
a branch (default: current branch), scanning the notes ref and matching
|
||||
notes on their `branch:` header. Exit 1 if there is no note for the branch.
|
||||
(A `previous`-chain walk cannot bootstrap from an unreviewed tip, so the
|
||||
scan uses the `branch:` header as the index instead.)
|
||||
- `review-note push` — `git push origin refs/notes/review`. Plain `git push`
|
||||
ignores notes, so this is the only way results travel.
|
||||
|
||||
`push` pushes without force; if the remote rejects, report the failure and let
|
||||
the user decide.
|
||||
|
||||
## Lifecycle
|
||||
|
||||
1. Reviewer reads `review-note latest <branch>` (exit 1 means first review).
|
||||
2. Reviewer reviews the branch tip per `REVIEW.md`.
|
||||
3. Reviewer writes the note with `review-note write` and runs
|
||||
`review-note push`.
|
||||
4. If the verdict is `request-changes`, the author pushes fixes as new
|
||||
commits. The next review round starts at the new tip with `round`+1,
|
||||
`previous` set to the last reviewed tip, and carried-forward findings.
|
||||
5. When the verdict is `approve` and the branch merges, the notes remain on
|
||||
the branch commits as the review record.
|
||||
|
||||
## Documentation integration
|
||||
|
||||
- `REVIEW.md` gains a "Recording reviews" section describing the protocol and
|
||||
the four script commands. This is the single source of truth for the
|
||||
protocol.
|
||||
- `AGENTS.md` "Reviewing" section gains one line pointing at the section, so
|
||||
any AI session picks up the flow automatically.
|
||||
|
||||
## Seeding the experiment
|
||||
|
||||
The failing review of `home_assistant_controller_cleanup` (commit `ba6e0e8`)
|
||||
becomes note round 1, with these findings:
|
||||
|
||||
- F1 (blocker, src/AFRP.hs:273): hlint's `\_ -> x` → `const x` rewrites break
|
||||
the rank-2 `Mealy` type; library does not compile.
|
||||
- F2 (blocker, test/AFRPLawsSpec.hs:98): seven law tests reduced to
|
||||
tautologies by hlint rewrites; see :103, :212, :221, :228, :235, :256.
|
||||
- F3 (minor, test/AFRPLawsSpec.hs:241): the interchange and composition laws
|
||||
were reshaped to `<$>` forms; fold them into the same hlint suppression.
|
||||
|
||||
## Verification
|
||||
|
||||
The script is verified by round-trip checks in a throwaway temp clone: write,
|
||||
show, latest (two rounds, branch filtering), force-overwrite refusal and
|
||||
acceptance, and push. No Haskell or cabal changes, so no
|
||||
cabal2nix regeneration.
|
||||
@@ -52,7 +52,7 @@ extra-doc-files: CHANGELOG.md
|
||||
-- extra-source-files:
|
||||
|
||||
common warnings
|
||||
ghc-options: -Wall
|
||||
ghc-options: -Wall -Werror
|
||||
|
||||
library
|
||||
-- Import common warning flags.
|
||||
@@ -60,20 +60,35 @@ library
|
||||
|
||||
-- Modules exported by the library.
|
||||
exposed-modules: AFRP
|
||||
, AFRP.Diagram
|
||||
, HomeAssistant.Controller
|
||||
, HomeAssistant.Controller.Bedroom
|
||||
, HomeAssistant.Controller.Hallway
|
||||
, HomeAssistant.Controller.Kitchen
|
||||
, HomeAssistant.Controller.Children
|
||||
, HomeAssistant.Controller.Door
|
||||
, HomeAssistant.Controller.Effect
|
||||
, HomeAssistant.Controller.Entity
|
||||
, HomeAssistant.Controller.Hallway
|
||||
, HomeAssistant.Controller.Ikea
|
||||
, HomeAssistant.Controller.Kitchen
|
||||
, HomeAssistant.Controller.Light.Command
|
||||
, HomeAssistant.Controller.Light.Mode
|
||||
, HomeAssistant.Controller.Light.Observation
|
||||
, HomeAssistant.Controller.Livingroom
|
||||
, HomeAssistant.Controller.Presence
|
||||
, HomeAssistant.Controller.Ruuvi
|
||||
, HomeAssistant.Controller.Scene
|
||||
, HomeAssistant.Controller.Service
|
||||
, HomeAssistant.Controller.Switch
|
||||
, HomeAssistant.Runtime
|
||||
, HomeAssistant.Runtime.Bus
|
||||
, HomeAssistant.Runtime.Connection
|
||||
, HomeAssistant.Runtime.Flags
|
||||
, HomeAssistant.Runtime.Graphing
|
||||
, HomeAssistant.Runtime.Metrics
|
||||
, HomeAssistant.Runtime.Supervisor
|
||||
, HomeAssistant.Runtime.RateLimit
|
||||
, HttpServer
|
||||
, Katip.Scribes.Journal
|
||||
|
||||
-- Modules included in this library but not exported.
|
||||
-- other-modules:
|
||||
@@ -84,6 +99,7 @@ library
|
||||
-- Other library packages from which modules are imported.
|
||||
build-depends: base ^>=4.20.2.0
|
||||
, websockets
|
||||
, http-media
|
||||
, aeson
|
||||
, lens-aeson
|
||||
, lens
|
||||
@@ -104,15 +120,21 @@ library
|
||||
, process
|
||||
, directory
|
||||
, cereal
|
||||
, cereal-text
|
||||
, containers
|
||||
, data-default
|
||||
, filepath
|
||||
, conduit
|
||||
, cereal-conduit
|
||||
, scotty
|
||||
, servant
|
||||
, servant-server
|
||||
, http-types
|
||||
, warp
|
||||
, wai
|
||||
, retry
|
||||
, libsystemd-journal
|
||||
, lucid2
|
||||
, http-api-data
|
||||
|
||||
-- Directories containing source files.
|
||||
hs-source-dirs: src
|
||||
@@ -154,14 +176,21 @@ test-suite home-assistant-controller-test
|
||||
|
||||
-- Modules included in this executable, other than Main.
|
||||
other-modules: AFRPLawsSpec
|
||||
, AFRPSpec
|
||||
, BedroomSpec
|
||||
, BusSpec
|
||||
, ConnectionSpec
|
||||
, GraphingSpec
|
||||
, MetricsSpec
|
||||
, RuntimeSpec
|
||||
, Support
|
||||
, AFRPSpec
|
||||
, BedroomSpec
|
||||
, BusSpec
|
||||
, ConnectionSpec
|
||||
, FlagsSpec
|
||||
, GraphingSpec
|
||||
, HallwaySpec
|
||||
, HttpServerSpec
|
||||
, KitchenSpec
|
||||
, LivingroomSpec
|
||||
, MetricsSpec
|
||||
, RuntimeSpec
|
||||
, Support
|
||||
, ControllerSpec
|
||||
, PresenceSpec
|
||||
|
||||
-- LANGUAGE extensions used by modules in this package.
|
||||
-- other-extensions:
|
||||
@@ -180,8 +209,10 @@ test-suite home-assistant-controller-test
|
||||
base ^>=4.20.2.0,
|
||||
home-assistant-controller,
|
||||
bytestring,
|
||||
data-default,
|
||||
hspec,
|
||||
stm,
|
||||
servant,
|
||||
aeson,
|
||||
cereal,
|
||||
text,
|
||||
@@ -196,4 +227,6 @@ test-suite home-assistant-controller-test
|
||||
ekg-core,
|
||||
unordered-containers,
|
||||
process,
|
||||
directory
|
||||
directory,
|
||||
temporary,
|
||||
lucid2
|
||||
Executable
+95
@@ -0,0 +1,95 @@
|
||||
#!/usr/bin/env bash
|
||||
# review-note: manage code-review notes under refs/notes/review.
|
||||
# The protocol lives in REVIEW.md.
|
||||
set -euo pipefail
|
||||
|
||||
NOTES_REF=refs/notes/review
|
||||
REMOTE=origin
|
||||
|
||||
die() { echo "review-note: $*" >&2; exit 1; }
|
||||
|
||||
usage() {
|
||||
cat >&2 <<'EOF'
|
||||
usage:
|
||||
review-note show [commit]
|
||||
review-note write <file> [--force]
|
||||
review-note latest [branch]
|
||||
review-note push
|
||||
EOF
|
||||
exit 1
|
||||
}
|
||||
|
||||
validate() {
|
||||
local file="$1"
|
||||
grep -q '^branch: .\+' "$file" || die "missing or empty 'branch:' header"
|
||||
grep -Eq '^round: [0-9]+$' "$file" || die "missing or invalid 'round:' header"
|
||||
grep -Eq '^verdict: (approve|request-changes)$' "$file" \
|
||||
|| die "verdict must be 'approve' or 'request-changes'"
|
||||
}
|
||||
|
||||
cmd_show() {
|
||||
local commit="${1:-HEAD}"
|
||||
git notes --ref="$NOTES_REF" show "$commit" 2>/dev/null \
|
||||
|| die "no review note for $commit"
|
||||
}
|
||||
|
||||
cmd_write() {
|
||||
local force="" file=""
|
||||
local arg
|
||||
for arg in "$@"; do
|
||||
case "$arg" in
|
||||
--force) force=1 ;;
|
||||
*) file="$arg" ;;
|
||||
esac
|
||||
done
|
||||
[ -n "$file" ] || usage
|
||||
[ -f "$file" ] || die "no such file: $file"
|
||||
local tip
|
||||
tip=$(git rev-parse HEAD)
|
||||
if [ -z "$force" ] && git notes --ref="$NOTES_REF" show "$tip" >/dev/null 2>&1; then
|
||||
die "tip $tip already has a review note; pass --force to replace"
|
||||
fi
|
||||
validate "$file"
|
||||
if [ -n "$force" ]; then
|
||||
git notes --ref="$NOTES_REF" add -f -F "$file" "$tip"
|
||||
else
|
||||
git notes --ref="$NOTES_REF" add -F "$file" "$tip"
|
||||
fi
|
||||
}
|
||||
|
||||
cmd_latest() {
|
||||
local branch="${1:-$(git branch --show-current)}"
|
||||
local blob obj note br rnd best="" best_round=-1
|
||||
while read -r blob obj; do
|
||||
note=$(git notes --ref="$NOTES_REF" show "$obj") || continue
|
||||
br=$(sed -n '/^$/q; s/^branch: //p' <<<"$note")
|
||||
[ "$br" = "$branch" ] || continue
|
||||
rnd=$(sed -n '/^$/q; s/^round: //p' <<<"$note")
|
||||
[[ "$rnd" =~ ^[0-9]+$ ]] || continue
|
||||
if [ "$rnd" -gt "$best_round" ]; then
|
||||
best_round=$rnd
|
||||
best=$note
|
||||
fi
|
||||
done < <(git notes --ref="$NOTES_REF" list)
|
||||
[ -n "$best" ] || die "no review notes for branch: $branch"
|
||||
printf '%s\n' "$best"
|
||||
}
|
||||
|
||||
cmd_push() {
|
||||
git rev-parse -q --verify "$NOTES_REF" >/dev/null || die "no review notes to push"
|
||||
git push "$REMOTE" "$NOTES_REF"
|
||||
}
|
||||
|
||||
main() {
|
||||
local cmd="${1:-}"
|
||||
if [ $# -gt 0 ]; then shift; fi
|
||||
case "$cmd" in
|
||||
show) cmd_show "$@" ;;
|
||||
write) cmd_write "$@" ;;
|
||||
latest) cmd_latest "$@" ;;
|
||||
push) cmd_push "$@" ;;
|
||||
*) usage ;;
|
||||
esac
|
||||
}
|
||||
|
||||
main "$@"
|
||||
Executable
+82
@@ -0,0 +1,82 @@
|
||||
#!/usr/bin/env bash
|
||||
# Round-trip checks for scripts/review-note, in a throwaway temp repo.
|
||||
set -euo pipefail
|
||||
|
||||
root=$(cd "$(dirname "$0")/.." && pwd -P)
|
||||
rn="$root/scripts/review-note"
|
||||
fail() { echo "FAIL: $*" >&2; exit 1; }
|
||||
tmp=$(mktemp -d)
|
||||
trap 'rm -rf "$tmp"' EXIT
|
||||
|
||||
git init -q --bare "$tmp/remote.git"
|
||||
git init -q -b main "$tmp/repo"
|
||||
cd "$tmp/repo"
|
||||
git config user.email test@example.com
|
||||
git config user.name test
|
||||
|
||||
echo one > a.txt && git add a.txt && git commit -qm one
|
||||
echo two > b.txt && git add b.txt && git commit -qm two
|
||||
|
||||
note="$tmp/note1"
|
||||
cat > "$note" <<'EOF'
|
||||
branch: main
|
||||
round: 1
|
||||
verdict: request-changes
|
||||
previous: none
|
||||
findings:
|
||||
- id: F1
|
||||
severity: blocker
|
||||
file: a.txt:1
|
||||
title: fix me
|
||||
status: open
|
||||
## Details
|
||||
|
||||
Fix it.
|
||||
EOF
|
||||
|
||||
if "$rn" show >/dev/null 2>&1; then fail "show should exit 1 without a note"; fi
|
||||
|
||||
sed '/^verdict:/d' "$note" > "$tmp/no-verdict"
|
||||
if "$rn" write "$tmp/no-verdict" >/dev/null 2>&1; then fail "write should refuse a missing verdict"; fi
|
||||
sed 's/^verdict: request-changes/verdict: maybe/' "$note" > "$tmp/bad-verdict"
|
||||
if "$rn" write "$tmp/bad-verdict" >/dev/null 2>&1; then fail "write should refuse a bad verdict"; fi
|
||||
|
||||
"$rn" write "$note"
|
||||
"$rn" show | grep -q '^verdict: request-changes$' || fail "show should print the note"
|
||||
|
||||
if "$rn" write "$note" >/dev/null 2>&1; then fail "write should refuse an existing note"; fi
|
||||
|
||||
sed 's/^verdict: request-changes/verdict: approve/' "$note" > "$tmp/note1b"
|
||||
"$rn" write "$tmp/note1b" --force
|
||||
"$rn" show | grep -q '^verdict: approve$' || fail "show should print the replaced note"
|
||||
"$rn" show | diff -u "$tmp/note1b" - || fail "show should print the note verbatim"
|
||||
|
||||
# latest finds the note by branch, even from a newer unreviewed tip
|
||||
echo three > c.txt && git add c.txt && git commit -qm three
|
||||
"$rn" latest main | grep -q '^verdict: approve$' || fail "latest should find the round 1 note"
|
||||
|
||||
# a note for another branch must not leak into the result
|
||||
sed -e 's/^branch: main/branch: other/' -e 's/^round: 1/round: 9/' "$tmp/note1b" > "$tmp/other"
|
||||
"$rn" write "$tmp/other"
|
||||
"$rn" latest main | grep -q '^verdict: approve$' || fail "latest should ignore other branches"
|
||||
|
||||
# round 2 on the new tip wins and carries previous (replaces the
|
||||
# other-branch note on the same commit, so --force)
|
||||
PREV=$(git rev-parse HEAD~1)
|
||||
sed -e 's/^round: 1/round: 2/' -e "s/^previous: none/previous: $PREV/" "$tmp/note1b" > "$tmp/note2"
|
||||
"$rn" write "$tmp/note2" --force
|
||||
"$rn" latest main | grep -q '^round: 2$' || fail "latest should pick the highest round"
|
||||
"$rn" latest main | grep -q "^previous: $PREV$" || fail "round 2 should carry previous"
|
||||
|
||||
if "$rn" latest nosuch >/dev/null 2>&1; then fail "latest should exit 1 for an unknown branch"; fi
|
||||
|
||||
# push publishes notes to origin; a fresh clone picks them up
|
||||
git remote add origin "$tmp/remote.git"
|
||||
git push -q origin main
|
||||
"$rn" push
|
||||
git clone -q "$tmp/remote.git" "$tmp/clone"
|
||||
cd "$tmp/clone"
|
||||
git fetch -q origin "refs/notes/review:refs/notes/review"
|
||||
"$rn" latest main | grep -q '^round: 2$' || fail "clone should see the round 2 note"
|
||||
|
||||
echo "ok: show/write/latest/push"
|
||||
+21
-21
@@ -1,28 +1,28 @@
|
||||
HA_TOKEN: ENC[AES256_GCM,data:zs9nTT2EV/OhBiH9alUuupUvYURXj40lxe7IKKWXdExW+BW98yEDHcQr/KNsQ0Iu9+U2GrsA8WpODeM351kI3Owj3rl082tObBJ2jwF1iyYcXhoH3xvbHb+HN802SBOTIO32m+ZwGvIVPjF8W+67eGKTrIUcqnKj7Ab/TchG+mYPLdil0mYjITY+DCUi0mW1nElCaTTexovj4PHlUdA1xIsCYF+XnTypQv8o+Zy8MsMZtdzNQKJG,iv:Lmxmp5y15sqhQvEO7liVk6x3Y26qtoL39TT2MSqZdok=,tag:1Xvs6YUilP/XH0UxYngTIg==,type:str]
|
||||
HA_HOST: ENC[AES256_GCM,data:MfA+RReJHnKP31bD4YAoZrc=,iv:Z9xDtzPsUER4jQ12BbM2EtnLNggZhOWzCb7VAL2I02g=,tag:/Eogbd2kT7phdhaR/vGNDA==,type:str]
|
||||
sops:
|
||||
age:
|
||||
- enc: |
|
||||
-----BEGIN AGE ENCRYPTED FILE-----
|
||||
YWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IHBpdi1wMjU2IHJKaXRSQSBBeEpPRXVT
|
||||
NDY2ZUxZRDB5a21waDFoUXJsQkdsbFhQRjhobFBGVDlaZmlpSApGNEpKS1JzUStw
|
||||
eWFJcUkxbWRtWURLQm0rWWtURXVNVEwvVlRLa3prNFZRCi0tLSBJWjhiL2RLV3ZO
|
||||
NStpUlVSRHlSTEJWa2ZkenI3T292RnMwaHB6cnJRSW1NCt3zpORUDB2m9V+IK9UI
|
||||
Z94uFopKZsRxzbxbZWklNykYoryjKfVCTO7sFDxapzr1UlG3UjVp2kgBJeDCEBVt
|
||||
SwQ=
|
||||
-----END AGE ENCRYPTED FILE-----
|
||||
recipient: age1yubikey1qw7m7rad6malegqypgntr7qmu97xrxxurp0c00s23263nuxnpek6w0jye60
|
||||
- enc: |
|
||||
-----BEGIN AGE ENCRYPTED FILE-----
|
||||
YWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IHBpdi1wMjU2IFVnM21GQSBBNFYvaEM2
|
||||
MFoyR3NhcDc4eklaTHJaUVZRWlJzT2dkclBOaExLYWZDb05DaQpidVcrRklydWJZ
|
||||
WUhxQUR1c281R1RtdGlxNy9uMmJPODE1YXQ1K2g3bnFJCi0tLSAwblViWnhPMUNC
|
||||
dTRoelphM1djcW9DK0NkWE44TSsvYmE5aEtIMW5RVG9vCqO5SqZ73i4wRn9qWyXA
|
||||
8bW5XLeTN4qCIeMFEKloiAKDUKFWutHt/9SedYUsqMuRmQ9btmWg5TdkHV4S/6iR
|
||||
qDU=
|
||||
-----END AGE ENCRYPTED FILE-----
|
||||
recipient: age1yubikey1qdnx7jum6k4fzenkqj8y5met9hyq6lqxrpzrl2788wr0q445vhupzuqtpk0
|
||||
lastmodified: "2026-08-21T10:17:59Z"
|
||||
mac: ENC[AES256_GCM,data:GuNyo/3flhR30e6kds1iXcDGmq0Xq2hqvBmAvYtakKwzUzMocP9vImfxs+MfVNiMGirlkwbihrX5mFSbfORjES/FDTs6p0100H1tkBqPTecW88PC6/66Js9umVevGYbgToCNBjV9mUBu7o7SyU+NYLnZ/8X4xdx0y6/MKnuvjUA=,iv:/nL5AIL80iV3sutjMTmHyF62SRezmX9XyJJ6+o9TdkQ=,tag:SNMu17rgMIhdzZVsGmXyfg==,type:str]
|
||||
pgp:
|
||||
- created_at: "2026-08-20T05:39:51Z"
|
||||
enc: |-
|
||||
-----BEGIN PGP MESSAGE-----
|
||||
|
||||
hQIMA5Urps8/GyTEAQ//ZQeXRy2SHcR2/hVqleE8V9/3u150TWX7GpDPVdjK7pxu
|
||||
zK1JZSw/FSpNrUPFHXk6rWDm6lv1k/GCx34egHwgumlO1/192nQLMxwNHXhDeJmc
|
||||
k6y44pb3Z1m/upVp62fIif2/f7X2BIQqGI0nZBaCM6sD5FE8HqXCk+jYw4YMvNZp
|
||||
I6dtxxnYwW5wK5Gfv86hTHkn2ibDqARMgd0QsB8fv9fpE9iHWTeeSHqkCBVnb5Kn
|
||||
s0Xk1DeED/ylLAlHfY0p0LVIjeCK5KCQCbIHXh4yb8ioxUxg9LQp8glXbjqbfaBx
|
||||
FadLksLDxBuO0CWxAB4bVk4G/MKCL1nN3KzZBWfy96aknHHGQre0DCe7IxfmSYjd
|
||||
f5UhfeFCVrWQTOtaoq3Oimw6CFeoGe04FKogQmZOWK1zmJmHxjCRGn4n5vzEZB1g
|
||||
Cq+fzDLl2+Krr91Wq/xGwatoWaPl+SDzw1i7CnfGhWJn50BtO/YI1229yLSyANhs
|
||||
M2R9JXxiWFst8xur0nJBKkzH+EZpaVOOLT7FgFpf/vWOO/se1kVPaMAhg6fQ3IwJ
|
||||
JphPD+FTkTDY4GBefVP/qOhOnibcIjhwTiDWP6ppcaOxgVjyDyLsqS96jYSwfyKQ
|
||||
puDyzrD4BlLv1lc2lULCtgMwZj428Vpd7YI1SjnxxKnKhIQ1IZx0ddneHn9fSivS
|
||||
XgE6NpQKQ110FFYse8P1fb2yNaYb2ZRbLh0cUOe2qcTATTvK5OdDVlgCjNsO8Fgl
|
||||
OO8hwmsk+1QziCwO4Md8NPdyNn4Kup1iRojMyAh23CT5LyYXoccakWvF/awLvz8=
|
||||
=nX50
|
||||
-----END PGP MESSAGE-----
|
||||
fp: 95DBE64C2EA64D6B0E0C8C2F9DE6E04ED1918118
|
||||
unencrypted_suffix: _unencrypted
|
||||
version: 3.13.3
|
||||
+81
-36
@@ -1,14 +1,16 @@
|
||||
{-# LANGUAGE LambdaCase #-}
|
||||
{-# LANGUAGE Arrows #-}
|
||||
{-# LANGUAGE TypeOperators #-}
|
||||
|
||||
module AFRP
|
||||
( Mealy(..)
|
||||
, Auto(..)
|
||||
, DecodedAuto(..)
|
||||
, eff
|
||||
, withEntities
|
||||
, named
|
||||
, Event(..)
|
||||
, hold
|
||||
, holdKnown
|
||||
, events
|
||||
-- , switch
|
||||
, preMapAccum
|
||||
@@ -18,8 +20,10 @@ module AFRP
|
||||
, changes
|
||||
, whenA
|
||||
, filterA
|
||||
, filterEvent
|
||||
, thenA
|
||||
, (>>|)
|
||||
, (>>||)
|
||||
, toEvent
|
||||
, lMerge
|
||||
, Pair(..)
|
||||
@@ -27,6 +31,7 @@ module AFRP
|
||||
, SerializeUTCTime(..)
|
||||
, SerializeLocalTime(..)
|
||||
, edge
|
||||
, edgeFrom
|
||||
, waitFor
|
||||
, duration
|
||||
, tag
|
||||
@@ -42,6 +47,7 @@ module AFRP
|
||||
, load
|
||||
, stepAuto
|
||||
, stepAutoSerializing
|
||||
, snapshot
|
||||
) where
|
||||
|
||||
import Control.Category (Category(..), (>>>))
|
||||
@@ -55,7 +61,7 @@ import qualified Data.Set as S
|
||||
import qualified Data.Text as T
|
||||
import Data.Serialize (Get, Putter, Serialize (put), runGet, get)
|
||||
import qualified Data.ByteString as B
|
||||
import Control.Exception (IOException, handle, throwIO)
|
||||
import Control.Exception (IOException)
|
||||
import System.IO.Error (isDoesNotExistError)
|
||||
import GHC.Generics (Generic)
|
||||
import Data.Sequence (Seq, (|>))
|
||||
@@ -64,6 +70,10 @@ import Control.Monad.IO.Class (MonadIO, liftIO)
|
||||
import Conduit (ConduitT, (.|))
|
||||
import qualified Data.Conduit.Cereal as CC
|
||||
import qualified Conduit as C
|
||||
import Control.Monad.Catch (MonadCatch, handle)
|
||||
import Control.Exception.Annotated (throw)
|
||||
import AFRP.Diagram
|
||||
import Data.Text (Text)
|
||||
|
||||
|
||||
data Codec s = Codec { getter :: !(Get s), putter :: !(Putter s) }
|
||||
@@ -103,9 +113,10 @@ mergeCodec (Codec agetter aputter) (Codec bgetter bputter) = Codec (mergeGet age
|
||||
data Pair a b = Pair !a !b
|
||||
|
||||
data Request = Request
|
||||
{ requestTime :: !UTCTime
|
||||
, requestTimeZone :: !TimeZone
|
||||
, requestTraceId :: !UUID
|
||||
{ requestTime :: !UTCTime
|
||||
, requestTimeZone :: !TimeZone
|
||||
, requestTraceId :: !UUID
|
||||
, requestHandler :: !T.Text
|
||||
} deriving (Show, Eq)
|
||||
|
||||
|
||||
@@ -125,7 +136,7 @@ instance Monad m => Applicative (Auto m a) where
|
||||
pure a = Fun (\_req -> const a)
|
||||
fa <*> fb =
|
||||
case (fa,fb) of
|
||||
(Fun af, Fun bf) -> Fun $ \req -> (af req <*> bf req)
|
||||
(Fun af, Fun bf) -> Fun $ \req -> af req <*> bf req
|
||||
(Stateful codec s af, Fun bf) -> Stateful codec s
|
||||
(\s' req x -> do
|
||||
let a = bf req x
|
||||
@@ -175,7 +186,7 @@ instance (Monad m, Monoid b) => Monoid (Auto m a b) where
|
||||
|
||||
|
||||
instance Monad m => Category (Auto m) where
|
||||
id = Fun $ \_ -> id
|
||||
id = Fun $ const id
|
||||
af . ag =
|
||||
case (af, ag) of
|
||||
(Fun f, Fun g) -> Fun (\req -> f req . g req)
|
||||
@@ -245,63 +256,66 @@ save path s
|
||||
isDirty _ = False
|
||||
|
||||
|
||||
load :: forall m a b. FilePath -> Auto m a b -> IO (DecodedAuto m a b)
|
||||
load path a = handle defaultOnMissingFile (flip deserialize a <$> B.readFile path)
|
||||
load :: forall eff a b m. (MonadCatch m, MonadIO m) => FilePath -> Auto eff a b -> m (DecodedAuto eff a b)
|
||||
load path a = handle defaultOnMissingFile (flip deserialize a <$> liftIO (B.readFile path))
|
||||
where
|
||||
defaultOnMissingFile :: IOException -> IO (DecodedAuto m a b)
|
||||
defaultOnMissingFile :: IOException -> m (DecodedAuto eff a b)
|
||||
defaultOnMissingFile e
|
||||
| isDoesNotExistError e = pure $ FailDecode "State doesn't exist yet" a
|
||||
| otherwise = throwIO e
|
||||
| otherwise = throw e
|
||||
|
||||
|
||||
-- | The set of entity ids an arrow subscribes to. Static: it does not
|
||||
-- change as the machine steps, so the runtime can read it once to build
|
||||
-- trigger subscriptions.
|
||||
data Mealy eff a b = Mealy
|
||||
{ entities :: S.Set T.Text
|
||||
, runDiagramC :: forall x. (DiagramF x -> x) -> x
|
||||
, runMealy :: forall m. Monad m => (forall x. eff x -> m x) -> Auto m a b
|
||||
}
|
||||
|
||||
-- Provide a name
|
||||
named :: Text -> Mealy eff a b -> Mealy eff a b
|
||||
named n f = f{runDiagramC = \run -> run (Step n (runDiagramC f run))}
|
||||
|
||||
instance Semigroup b => Semigroup (Mealy eff a b) where
|
||||
Mealy ast af <> Mealy bst bf = Mealy (ast <> bst) $ \nt -> af nt <> bf nt
|
||||
Mealy ast ad af <> Mealy bst bd bf = Mealy (ast <> bst) (combineDiagram Merge ad bd) $ \nt -> af nt <> bf nt
|
||||
|
||||
|
||||
instance Monoid b => Monoid (Mealy eff a b) where
|
||||
mempty = Mealy mempty $ \_nt -> mempty
|
||||
-- where
|
||||
-- m = Mealy mempty $ \_ _ _ -> pure (Pair mempty m)
|
||||
mempty = Mealy mempty emptyDiagram $ \_nt -> mempty
|
||||
|
||||
eff :: (Request -> a -> eff b) -> Mealy eff a b
|
||||
eff f = Mealy mempty $ \nt -> do
|
||||
eff f = Mealy mempty emptyDiagram $ \nt -> do
|
||||
Stateful (Codec get put) (State () False) $ \s req a -> do
|
||||
b <- nt (f req a)
|
||||
pure (b, s)
|
||||
|
||||
-- | Override the static entity set of an arrow. Use when a combinator
|
||||
-- (e.g. 'switch') hides continuation entities from the runtime's
|
||||
-- startup subscription scan.
|
||||
withEntities :: S.Set T.Text -> Mealy eff a b -> Mealy eff a b
|
||||
withEntities es (Mealy _ f) = Mealy es f
|
||||
|
||||
instance Category (Mealy eff) where
|
||||
id = Mealy mempty (\_ -> id)
|
||||
(Mealy ast f) . (Mealy bst g) = Mealy (ast <> bst) $ \nt -> do
|
||||
{- HLINT ignore "Use const" -}
|
||||
id = Mealy mempty emptyDiagram $ \_nt -> id
|
||||
(Mealy ast ad f) . (Mealy bst bd g) = Mealy (ast <> bst) (combineDiagram Then bd ad) $ \nt -> do
|
||||
f nt . g nt
|
||||
|
||||
instance Arrow (Mealy eff) where
|
||||
arr f = Mealy mempty $ \_nt -> arr f
|
||||
first (Mealy st f) = Mealy st $ \nt -> first (f nt)
|
||||
arr f = Mealy mempty emptyDiagram $ \_nt -> arr f
|
||||
first (Mealy st d f) = Mealy st d $ \nt -> first (f nt)
|
||||
(Mealy ast ad f) &&& (Mealy bst bd g) = Mealy (ast <> bst) (combineDiagram Both ad bd) $ \nt -> do
|
||||
f nt &&& g nt
|
||||
|
||||
instance ArrowChoice (Mealy eff) where
|
||||
left (Mealy st f) = Mealy st $ \nt -> left (f nt)
|
||||
left (Mealy st d f) = Mealy st d $ \nt -> left (f nt)
|
||||
(Mealy ast ad f) +++ (Mealy bst bd g) = Mealy (ast <> bst) (combineDiagram Branch ad bd) $ \nt -> do
|
||||
f nt +++ g nt
|
||||
|
||||
|
||||
instance Functor (Mealy eff a) where
|
||||
fmap f (Mealy st g) = Mealy st $ \nt -> fmap f (g nt)
|
||||
fmap f (Mealy st d g) = Mealy st d $ \nt -> fmap f (g nt)
|
||||
|
||||
instance Applicative (Mealy eff a) where
|
||||
pure b = Mealy mempty $ \_ -> pure b
|
||||
Mealy ast f <*> Mealy bst x = Mealy (ast <> bst) $ \nt ->
|
||||
pure b = Mealy mempty emptyDiagram $ \_ -> pure b
|
||||
Mealy ast ad f <*> Mealy bst bd x = Mealy (ast <> bst) (combineDiagram Compose ad bd) $ \nt ->
|
||||
f nt <*> x nt
|
||||
|
||||
data Event a
|
||||
@@ -325,6 +339,16 @@ hold def = mapAccum step def id
|
||||
Event new -> new
|
||||
|
||||
|
||||
-- A variant of 'hold' which makes it explicit whether we have a previous value
|
||||
holdKnown :: (Serialize a, Eq a) => Mealy m (Event a) (Maybe a)
|
||||
holdKnown = arr (fmap Just) >>> hold Nothing
|
||||
|
||||
snapshot :: (Serialize a, Eq a) => a -> Mealy m (Event x, a) a
|
||||
snapshot def = mapAccum step def id
|
||||
where
|
||||
step prev (Tick, _) = prev
|
||||
step _prev (Event _, a) = a
|
||||
|
||||
events :: Mealy eff (Event a) (Either () a)
|
||||
events = arr $ \case
|
||||
Tick -> Left ()
|
||||
@@ -356,10 +380,10 @@ preMapAccum' f x extract = Stateful (Codec get put) (pure x) (\s _req a -> pure
|
||||
|
||||
|
||||
mapAccum :: (Eq x, Serialize x) => (x -> a -> x) -> x -> (x -> b) -> Mealy eff a b
|
||||
mapAccum step x extract = Mealy mempty $ \_nt -> mapAccum' step x extract
|
||||
mapAccum step x extract = Mealy mempty emptyDiagram $ \_nt -> mapAccum' step x extract
|
||||
|
||||
preMapAccum :: (Eq x, Serialize x) => (x -> a -> x) -> x -> (x -> b) -> Mealy eff a b
|
||||
preMapAccum step x extract = Mealy mempty $ \_nt -> preMapAccum' step x extract
|
||||
preMapAccum step x extract = Mealy mempty emptyDiagram $ \_nt -> preMapAccum' step x extract
|
||||
|
||||
mapAccum' :: forall m x a b. (Monad m, Eq x, Serialize x) => (x -> a -> x) -> x -> (x -> b) -> Auto m a b
|
||||
mapAccum' f x extract = Stateful (Codec get put) (pure x) (\s _req a -> pure $ step s a)
|
||||
@@ -368,7 +392,7 @@ mapAccum' f x extract = Stateful (Codec get put) (pure x) (\s _req a -> pure $ s
|
||||
step s a = let s' = f (state s) a in (extract s', State s' (dirty s || state s /= s'))
|
||||
|
||||
preMapAccumRequest :: (Serialize x, Eq x) => (Request -> x -> a -> x) -> x -> (x -> b) -> Mealy eff a b
|
||||
preMapAccumRequest step x extract = Mealy mempty $ \_ -> preMapAccumRequest' step x extract
|
||||
preMapAccumRequest step x extract = Mealy mempty emptyDiagram $ \_ -> preMapAccumRequest' step x extract
|
||||
|
||||
preMapAccumRequest' :: forall m x a b. (Serialize x, Eq x, Monad m) => (Request -> x -> a -> x) -> x -> (x -> b) -> Auto m a b
|
||||
preMapAccumRequest' f x extract = Stateful (Codec get put) (State x False) (\s req a -> pure $ step s req a)
|
||||
@@ -377,7 +401,7 @@ preMapAccumRequest' f x extract = Stateful (Codec get put) (State x False) (\s r
|
||||
step s req a = let s' = f req (state s) a in (extract (state s), State s' (dirty s || state s /= s'))
|
||||
|
||||
mapAccumRequest :: (Serialize x, Eq x) => (Request -> x -> a -> x) -> x -> (x -> b) -> Mealy eff a b
|
||||
mapAccumRequest step x extract = Mealy mempty $ \_ -> mapAccumRequest' step x extract
|
||||
mapAccumRequest step x extract = Mealy mempty emptyDiagram $ \_ -> mapAccumRequest' step x extract
|
||||
|
||||
mapAccumRequest' :: forall m x a b. (Monad m, Serialize x, Eq x) => (Request -> x -> a -> x) -> x -> (x -> b) -> Auto m a b
|
||||
mapAccumRequest' f x extract = Stateful (Codec get put) (State x False) (\s req a -> pure $ step s req a)
|
||||
@@ -471,6 +495,13 @@ whenA predicate auto = arr (\a -> if predicate a then Left a else Right ()) >>>
|
||||
filterA :: (a -> Bool) -> Mealy eff a (Either () a)
|
||||
filterA f = arr $ \a -> bool (Left ()) (Right a) (f a)
|
||||
|
||||
-- filters events through if they match the predicate
|
||||
filterEvent :: (ArrowChoice cat, Arrow cat) => (a -> Bool) -> Event a `cat` Event a
|
||||
filterEvent predicate = proc ev -> do
|
||||
case ev of
|
||||
Event a | predicate a -> id -< ev
|
||||
_ -> arr (const Tick) -< ()
|
||||
|
||||
thenA :: (ArrowChoice cat, Arrow cat) => cat a (Either b1 c) -> cat c (Either b1 b2) -> cat a (Either b1 b2)
|
||||
thenA f g = f >>> arr Left ||| g
|
||||
|
||||
@@ -479,6 +510,15 @@ thenA f g = f >>> arr Left ||| g
|
||||
|
||||
infixl 2 >>|
|
||||
|
||||
(>>||) :: (ArrowChoice cat, Arrow cat) => cat a (Event b) -> cat b c -> cat a (Event c)
|
||||
f >>|| g = proc x -> do
|
||||
e <- f -< x
|
||||
case e of
|
||||
Event e' -> g >>> arr Event -< e'
|
||||
Tick -> arr (const Tick) -< ()
|
||||
|
||||
infixr 1 >>||
|
||||
|
||||
toEvent :: Mealy eff (Either () a) (Event a)
|
||||
toEvent = arr (either (const Tick) Event)
|
||||
|
||||
@@ -489,10 +529,15 @@ lMerge (Event a) _ = Event a
|
||||
lMerge Tick (Event a) = Event a
|
||||
|
||||
edge :: Mealy eff Bool (Event ())
|
||||
edge =
|
||||
edge = edgeFrom False
|
||||
|
||||
-- | Edge that behaves as if the input has been `start` forever, so the first
|
||||
-- True input does not fire when `start` is already True (no transition).
|
||||
edgeFrom :: Bool -> Mealy eff Bool (Event ())
|
||||
edgeFrom start =
|
||||
mapAccum
|
||||
(\(_, current) new -> (current, new))
|
||||
(False, False)
|
||||
(start, start)
|
||||
(\(old, current) ->
|
||||
if not old && current
|
||||
then Event ()
|
||||
@@ -593,7 +638,7 @@ requestLocalTime :: Request -> LocalTime
|
||||
requestLocalTime Request{requestTime, requestTimeZone} = utcToLocalTime requestTimeZone requestTime
|
||||
|
||||
currentTime :: Mealy eff a LocalTime
|
||||
currentTime = Mealy mempty $ \_nt -> Fun $ \req _ ->
|
||||
currentTime = Mealy mempty emptyDiagram $ \_nt -> Fun $ \req _ ->
|
||||
requestLocalTime req
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,49 @@
|
||||
{-# LANGUAGE OverloadedStrings #-}
|
||||
module AFRP.Diagram where
|
||||
import Data.Text (Text)
|
||||
import qualified Text.Printf as Text
|
||||
import qualified Data.Text as T
|
||||
|
||||
-- For rendering the arrows
|
||||
data DiagramF f
|
||||
= Empty
|
||||
| Step Text f -- Named step
|
||||
| Then f f -- >>>
|
||||
| Both f f -- &&&
|
||||
| Branch f f -- |||
|
||||
| Merge f f -- <>
|
||||
| Compose f f -- <*>
|
||||
|
||||
type DiagramAlgebra a = DiagramF a -> a
|
||||
type DiagramC= forall a. DiagramAlgebra a -> a
|
||||
|
||||
combineDiagram :: (forall a. a -> a -> DiagramF a) -> DiagramC -> DiagramC -> DiagramC
|
||||
combineDiagram constructor a b r = r (constructor (a r) (b r))
|
||||
|
||||
emptyDiagram :: DiagramC
|
||||
emptyDiagram r = r Empty
|
||||
|
||||
|
||||
renderF :: DiagramF (Maybe T.Text) -> Maybe T.Text
|
||||
renderF = \case
|
||||
Empty -> Nothing
|
||||
Step n x -> Just $ n <> T.pack (maybe "" (Text.printf "( %s )") x)
|
||||
Then (Just a) (Just b) -> Just $ a <> " -> " <> b
|
||||
Then (Just a) _ -> Just a
|
||||
Then _ b -> b
|
||||
Both (Just a) (Just b) -> Just $ T.pack $ Text.printf "(%s, %s)" a b
|
||||
Both (Just a) _ -> Just a
|
||||
Both _ b -> b
|
||||
Branch (Just a) (Just b) -> Just $ T.pack $ Text.printf "(%s || %s)" a b
|
||||
-- I'm leaving this here. This would be technically more correct (showing
|
||||
-- the empty branch, ie. the full if-then-else, but often we care about a
|
||||
-- more simplistic `when` style structure
|
||||
-- Branch (Just a) Nothing -> Just $ T.pack $ Text.printf "(%s || <skip>)" a
|
||||
Branch (Just a) Nothing -> Just $ T.pack $ Text.printf "%s" a
|
||||
Branch _ b -> b
|
||||
Merge (Just a) (Just b) -> Just $ T.pack $ Text.printf "(%s, %s)" a b
|
||||
Merge (Just a) _ -> Just a
|
||||
Merge _ b -> b
|
||||
Compose (Just a) (Just b) -> Just $ T.pack $ Text.printf "(%s, %s)" a b
|
||||
Compose (Just a) _ -> Just a
|
||||
Compose _ b -> b
|
||||
+12
-264
@@ -1,267 +1,15 @@
|
||||
{-# LANGUAGE Arrows #-}
|
||||
{-# LANGUAGE OverloadedStrings #-}
|
||||
{-# LANGUAGE LambdaCase #-}
|
||||
{-# LANGUAGE GADTs #-}
|
||||
|
||||
module HomeAssistant.Controller
|
||||
( Service(..)
|
||||
, HASSEff(..)
|
||||
, HASS
|
||||
, callService
|
||||
, callServiceDyn
|
||||
, entityChangeEvent
|
||||
, entityChangeEvent'
|
||||
, entityRead
|
||||
, entityRead'
|
||||
, entityBool
|
||||
, entityBool'
|
||||
, DoorState(..)
|
||||
, light
|
||||
, Presence(..)
|
||||
, presence
|
||||
, motion
|
||||
, motionToPresence
|
||||
, debug
|
||||
, traceEvent
|
||||
, traceValue
|
||||
, switch
|
||||
, Target(..)
|
||||
, brightness
|
||||
, Light(..)
|
||||
, ikeaQuickButton
|
||||
, IkeaButton(..)
|
||||
, IkeaGesture(..)
|
||||
, activateScene
|
||||
, ikeaBoxRemote
|
||||
, IkeaController(..)
|
||||
( module Export
|
||||
) where
|
||||
|
||||
import AFRP (Mealy (..), eff, Event(..), events, filterA, (>>|), toEvent, Request, hold, lMerge, waitFor, tag, edge)
|
||||
import Control.Arrow (Arrow(..), returnA)
|
||||
import Control.Category ((>>>))
|
||||
import Data.Aeson (Value, object, (.=))
|
||||
import qualified Data.Text as T
|
||||
import qualified Data.Set as S
|
||||
import Control.Lens (has, only, (^?), to, traversed)
|
||||
import Data.Aeson.Lens (key, _String, _Integral)
|
||||
import qualified Data.Text.Lens as TL
|
||||
import Data.Bool (bool)
|
||||
import Data.Serialize (Serialize)
|
||||
import GHC.Generics (Generic)
|
||||
import Data.Time (NominalDiffTime)
|
||||
|
||||
data Target = EntityId !T.Text | AreaId !T.Text
|
||||
deriving (Show,Eq,Ord)
|
||||
|
||||
data Service = Service
|
||||
{ serviceDomain :: T.Text
|
||||
, serviceName :: T.Text
|
||||
, serviceData :: Maybe Value
|
||||
, serviceTarget :: [Target]
|
||||
}
|
||||
deriving (Show, Eq)
|
||||
|
||||
data HASSEff a where
|
||||
CallService :: Request -> Service -> HASSEff ()
|
||||
Debug :: Show a => a -> HASSEff ()
|
||||
Trace :: Show a => Request -> a -> HASSEff ()
|
||||
|
||||
type HASS a b = Mealy HASSEff a b
|
||||
|
||||
callService :: Service -> HASS a ()
|
||||
callService service = eff (\req _ -> CallService req service)
|
||||
|
||||
callServiceDyn :: (a -> Service) -> HASS a ()
|
||||
callServiceDyn mkService = eff (\req a -> CallService req (mkService a))
|
||||
|
||||
debug :: Show a => HASS a a
|
||||
debug = proc x -> do
|
||||
eff (const Debug) -< x
|
||||
returnA -< x
|
||||
|
||||
traceEvent :: Show a => HASS (Event a) (Event a)
|
||||
traceEvent = proc ev -> do
|
||||
case ev of
|
||||
Event a -> eff Trace -< a
|
||||
Tick -> returnA -< ()
|
||||
returnA -< ev
|
||||
|
||||
traceValue :: Show a => HASS a a
|
||||
traceValue = proc x -> do
|
||||
eff Trace -< x
|
||||
returnA -< x
|
||||
|
||||
data DoorState = Open | Closed
|
||||
deriving (Show, Eq, Generic)
|
||||
|
||||
instance Serialize DoorState
|
||||
|
||||
data Presence = Occupied | Unoccupied
|
||||
deriving (Show, Eq, Generic)
|
||||
|
||||
instance Serialize Presence
|
||||
|
||||
presence :: T.Text -> HASS (Event Value) (Event Presence)
|
||||
presence entityId = entityBool entityId
|
||||
>>> arr (fmap (bool Unoccupied Occupied))
|
||||
|
||||
|
||||
data Motion = MotionDetected | MotionNotDetected | MotionUnknown
|
||||
deriving (Show, Eq, Generic)
|
||||
|
||||
|
||||
motion :: T.Text -> HASS (Event Value) Motion
|
||||
motion entityId = entityBool entityId
|
||||
>>> arr (fmap (bool MotionNotDetected MotionDetected))
|
||||
>>> hold MotionUnknown
|
||||
|
||||
|
||||
-- Convert a motion status into a simulated presence
|
||||
--
|
||||
-- A motion tracker detects _motion_, but if you are still, it can't detect you.
|
||||
-- A simple and cheap heuristic is to assume the person is a bit longer there
|
||||
motionToPresence :: NominalDiffTime -> HASS Motion Presence
|
||||
motionToPresence delay = (eventOccupied &&& eventUnoccupied)
|
||||
>>> arr (uncurry lMerge)
|
||||
>>> AFRP.hold Unoccupied
|
||||
where
|
||||
eventOccupied :: HASS Motion (Event Presence)
|
||||
eventOccupied = arr (== MotionDetected) >>> edge >>> arr (fmap (const Occupied))
|
||||
eventUnoccupied :: HASS Motion (Event Presence)
|
||||
eventUnoccupied = arr (== MotionNotDetected) >>> waitFor delay >>> arr (tag Unoccupied)
|
||||
|
||||
instance Serialize Motion
|
||||
|
||||
data Light
|
||||
= Off
|
||||
| On { brightnessPercentage :: Maybe Double }
|
||||
|
||||
-- Turn off lights when door is closed
|
||||
light :: [Target] -> Light -> Service
|
||||
light targets (On {brightnessPercentage}) = Service
|
||||
{ serviceDomain="light"
|
||||
, serviceName= "turn_on"
|
||||
, serviceData=fmap (\pct -> object ["brightness_pct" .= pct]) brightnessPercentage
|
||||
, serviceTarget=targets
|
||||
}
|
||||
light targets Off = Service
|
||||
{ serviceDomain="light"
|
||||
, serviceName= "turn_off"
|
||||
, serviceData=Nothing
|
||||
, serviceTarget=targets
|
||||
}
|
||||
|
||||
-- Name conflict with AFRP
|
||||
switch :: [Target] -> Bool -> Service
|
||||
switch targets b = Service
|
||||
{ serviceDomain="switch"
|
||||
, serviceName= bool "turn_off" "turn_on" b
|
||||
, serviceData=Nothing
|
||||
, serviceTarget=targets
|
||||
}
|
||||
|
||||
|
||||
entityChangeEvent :: T.Text -> Mealy eff (Event Value) (Event Value)
|
||||
entityChangeEvent entityId = entityChangeEvent' entityId >>> toEvent
|
||||
|
||||
entityChangeEvent' :: T.Text -> Mealy eff (Event Value) (Either () Value)
|
||||
entityChangeEvent' entityId = Mealy (S.singleton entityId) $ runMealy (events >>| filterA isEntity)
|
||||
where
|
||||
isEntity :: Value -> Bool
|
||||
isEntity = has (key "event" . key "variables" . key "trigger" . key "entity_id" . _String . only entityId)
|
||||
|
||||
entityRead' :: (Read a) => T.Text -> Mealy eff (Event Value) (Either () a)
|
||||
entityRead' entityId = entityChangeEvent' entityId >>| (arr state >>> arr (maybe (Left ()) Right))
|
||||
where
|
||||
state v = v ^? key "event" . key "variables" . key "trigger" . key "to_state" . key "state" . _String . TL.unpacked . to read
|
||||
|
||||
entityBool' :: T.Text -> Mealy eff (Event Value) (Either () Bool)
|
||||
entityBool' entityId = entityChangeEvent' entityId >>| (arr state >>> arr (maybe (Left ()) Right))
|
||||
where
|
||||
state v = v ^? key "event" . key "variables" . key "trigger" . key "to_state" . key "state" . _String . TL.unpacked . to toBool
|
||||
toBool = \case
|
||||
"on" -> True
|
||||
"off" -> False
|
||||
_ -> False
|
||||
|
||||
entityRead :: (Read a) => T.Text -> Mealy eff (Event Value) (Event a)
|
||||
entityRead entityId = entityRead' entityId >>> toEvent
|
||||
|
||||
entityBool :: T.Text -> Mealy eff (Event Value) (Event Bool)
|
||||
entityBool entityId = entityBool' entityId >>> toEvent
|
||||
|
||||
brightness :: T.Text -> HASS (Event Value) (Event Int)
|
||||
brightness entityId =
|
||||
entityChangeEvent' entityId
|
||||
>>| arr (maybe (Left ()) Right . eventBrightness)
|
||||
>>> AFRP.toEvent
|
||||
where
|
||||
eventBrightness v = v ^? key "event" . key "variables" . key "trigger" . key "to_state" . key "attributes" . key "brightness" . _Integral
|
||||
|
||||
data IkeaGesture
|
||||
= ShortClick
|
||||
| ShortRelease
|
||||
| DoubleClick
|
||||
| LongClick
|
||||
deriving Show
|
||||
|
||||
data IkeaButton a = OnButton !a | OffButton !a
|
||||
deriving Show
|
||||
|
||||
|
||||
toIkeaQuickButton :: T.Text -> Maybe (IkeaButton IkeaGesture)
|
||||
toIkeaQuickButton = \case
|
||||
-- 1 is on, 2 is off side of the button
|
||||
"1_initial_press" -> Just $ OnButton ShortClick
|
||||
"1_short_release" -> Just $ OnButton ShortRelease
|
||||
"1_double_press" -> Just $ OnButton DoubleClick
|
||||
"1_long_press" -> Just $ OnButton LongClick
|
||||
"2_initial_press" -> Just $ OffButton ShortClick
|
||||
"2_short_release" -> Just $ OffButton ShortRelease
|
||||
"2_double_press" -> Just $ OffButton DoubleClick
|
||||
"2_long_press" -> Just $ OffButton LongClick
|
||||
_ -> Nothing
|
||||
|
||||
ikeaQuickButton :: T.Text -> HASS (Event Value) (Event (IkeaButton IkeaGesture))
|
||||
ikeaQuickButton entityId =
|
||||
entityChangeEvent' entityId
|
||||
>>| arr (maybe (Left ()) Right . eventType)
|
||||
>>> toEvent
|
||||
where
|
||||
eventType v = v ^? key "event" . key "variables" . key "trigger" . key "to_state" . key "attributes" . key "event_type" . _String . to toIkeaQuickButton . traversed
|
||||
|
||||
data IkeaController
|
||||
= ControllerOn -- Short press on
|
||||
| ControllerOff -- Short press off
|
||||
| ControllerBrighnessUp -- Turn brightness up
|
||||
| ControllerBrighnessDown -- Turn brighness down
|
||||
| ControllerArrowRight -- Turn brighness down
|
||||
| ControllerArrowLeft -- Turn brighness down
|
||||
| ControllerBrighnessStop
|
||||
deriving Show
|
||||
|
||||
toIkeaController :: T.Text -> Maybe IkeaController
|
||||
toIkeaController = \case
|
||||
"on" -> Just ControllerOn
|
||||
"off" -> Just ControllerOff
|
||||
"brightness_move_up" -> Just ControllerBrighnessUp
|
||||
"brightness_move_down" -> Just ControllerBrighnessDown
|
||||
"brightness_stop" -> Just ControllerBrighnessStop
|
||||
"arrow_right_click" -> Just ControllerArrowRight
|
||||
"arrow_left_click" -> Just ControllerArrowLeft
|
||||
_ -> Nothing
|
||||
|
||||
ikeaBoxRemote :: T.Text -> HASS (Event Value) (Event IkeaController)
|
||||
ikeaBoxRemote entityId = entityChangeEvent' entityId
|
||||
>>| arr (maybe (Left ()) Right . eventType)
|
||||
>>> toEvent
|
||||
where
|
||||
eventType v = v ^? key "event" . key "variables" . key "trigger" . key "to_state" . key "attributes" . key "event_type" . _String . to toIkeaController . traversed
|
||||
|
||||
activateScene :: T.Text -> Service
|
||||
activateScene sceneId = Service
|
||||
{ serviceDomain="scene"
|
||||
, serviceName= "turn_on"
|
||||
, serviceTarget= [EntityId sceneId]
|
||||
, serviceData = Nothing
|
||||
}
|
||||
import HomeAssistant.Controller.Service as Export
|
||||
import HomeAssistant.Controller.Effect as Export
|
||||
import HomeAssistant.Controller.Entity as Export
|
||||
import HomeAssistant.Controller.Presence as Export
|
||||
import HomeAssistant.Controller.Door as Export
|
||||
import HomeAssistant.Controller.Switch as Export
|
||||
import HomeAssistant.Controller.Scene as Export
|
||||
import HomeAssistant.Controller.Ikea as Export
|
||||
import HomeAssistant.Controller.Light.Command as Export
|
||||
import HomeAssistant.Controller.Light.Observation as Export
|
||||
import HomeAssistant.Controller.Light.Mode as Export
|
||||
@@ -4,17 +4,20 @@ module HomeAssistant.Controller.Bedroom where
|
||||
|
||||
import HomeAssistant.Controller
|
||||
import qualified Data.Text as T
|
||||
import AFRP (Event (..), lMerge, duration, edge)
|
||||
import AFRP (Event (..), edge, filterEvent, hold, named, snapshot, tag, waitFor, (>>||))
|
||||
import Data.Aeson (Value, object, (.=))
|
||||
import Control.Arrow ((>>>), returnA, arr, Arrow (..))
|
||||
import Data.Bool (bool)
|
||||
import Data.Time (NominalDiffTime)
|
||||
import qualified AFRP
|
||||
import Data.Map (Map)
|
||||
import qualified Data.Map.Strict as M
|
||||
import Data.Serialize.Text ()
|
||||
import Data.Default (def)
|
||||
|
||||
|
||||
|
||||
bedroomLights :: [Target]
|
||||
bedroomLights = map EntityId ["light.bedroom_masse","light.bedroom_jemina","light.bedroom_ceiling","light.bedroom_led_switch"]
|
||||
bedroomLightTargets :: [Target]
|
||||
bedroomLightTargets = map EntityId ["light.bedroom_masse","light.bedroom_jemina","light.bedroom_ceiling","light.bedroom_led_switch"]
|
||||
|
||||
createBedroomScene :: Service
|
||||
createBedroomScene = Service
|
||||
@@ -22,61 +25,95 @@ createBedroomScene = Service
|
||||
, serviceName= "create"
|
||||
, serviceData= Just $ object
|
||||
[ "scene_id" .= ("makuuhuone_lights_snapshot" :: T.Text)
|
||||
, "snapshot_entities" .= [l | EntityId l <- bedroomLights]
|
||||
, "snapshot_entities" .= [l | EntityId l <- bedroomLightTargets]
|
||||
]
|
||||
, serviceTarget= []
|
||||
, serviceExclusions= []
|
||||
}
|
||||
|
||||
data PresenceLights
|
||||
= LightsOn -- Restore lights
|
||||
| LightsOff -- Timer expired, darkness
|
||||
| LightsSleep -- No presence detected, sleep mode
|
||||
deriving Show
|
||||
|
||||
-- Bedroom presence
|
||||
bedroomPresence :: HASS (Event Value) (Event Presence)
|
||||
bedroomPresence = presence "binary_sensor.presence_sensor_bedroom_occupancy"
|
||||
|
||||
presenceLightEvents :: HASS (Event Value) (Event PresenceLights)
|
||||
presenceLightEvents =
|
||||
bedroomPresence >>> AFRP.hold Unoccupied
|
||||
>>> arr lightWanted
|
||||
>>> (sleepEvent &&& offEvent &&& onEvent)
|
||||
>>> arr (\(s,(o,n)) -> s `AFRP.lMerge` o `AFRP.lMerge` n)
|
||||
where
|
||||
lightWanted o = o == Occupied
|
||||
sleepEvent = arr not >>> AFRP.edge >>> arr (AFRP.tag LightsSleep)
|
||||
onEvent = AFRP.edge >>> arr (AFRP.tag LightsOn)
|
||||
offEvent = arr not >>> AFRP.waitFor 300 >>> arr (AFRP.tag LightsOff)
|
||||
bedroomPresenceOccupied :: HASS (Event Value) Bool
|
||||
bedroomPresenceOccupied = bedroomPresence >>> hold Unoccupied >>> arr (== Occupied)
|
||||
|
||||
bedroomLightStatus :: HASS (Event Value) (Map T.Text LightObservation)
|
||||
bedroomLightStatus = M.fromList <$> traverse (\e -> (e,) <$> observedLight e) [e | EntityId e <- bedroomLightTargets]
|
||||
|
||||
-- Ready to sleep: someone detected and every light off or dimmed far down
|
||||
readyForSleep :: HASS (Event Value) Bool
|
||||
readyForSleep = (&&) <$> bedroomPresenceOccupied <*> (all sleepLight . M.elems <$> bedroomLightStatus)
|
||||
where
|
||||
-- ~10% of the 0-255 brightness range
|
||||
sleepLight o = not (observedOn o) || maybe False (<= 25) (observedBrightness o)
|
||||
|
||||
lightLevel :: HASS (Event Value) Int
|
||||
lightLevel = entityRead "sensor.presence_sensor_bedroom_light_level" >>> AFRP.hold 1
|
||||
|
||||
-- Snapshot the light status when leaving (presence turning unoccupied),
|
||||
-- restored on the next entry.
|
||||
snapshotOnLeaving :: HASS (Event Value) (Map T.Text LightObservation)
|
||||
snapshotOnLeaving =
|
||||
(bedroomPresenceOccupied &&& bedroomLightStatus)
|
||||
>>> first (arr not >>> edge)
|
||||
>>> snapshot M.empty
|
||||
|
||||
-- The light reactions run "in parallel"; there is a chance that two
|
||||
-- services are called in one go
|
||||
bedroomPresenceController :: HASS (Event Value) ()
|
||||
bedroomPresenceController = proc x -> do
|
||||
p <- presenceLightEvents >>> traceEvent -< x
|
||||
case p of
|
||||
Event LightsOff -> do
|
||||
callService (light bedroomLights Off) -< ()
|
||||
Event LightsOn -> do
|
||||
sleepMode -< False
|
||||
callService (activateScene "scene.makuuhuone_lights_snapshot") -< ()
|
||||
Event LightsSleep -> do
|
||||
callService createBedroomScene -< ()
|
||||
sleepMode -< True
|
||||
_ -> returnA -< ()
|
||||
|
||||
bedroomPresenceController =
|
||||
((,,,) <$> bedroomPresenceOccupied <*> cappedLightLevel <*> bedroomLightStatus <*> snapshotOnLeaving)
|
||||
>>> mconcat
|
||||
[ AFRP.named "Lights on" lightsOn
|
||||
, AFRP.named "Lights sleep" lightsSleep
|
||||
, AFRP.named "Lights off" lightsOff
|
||||
]
|
||||
>>> arr (const ()) -- I don't like this extra arr here
|
||||
where
|
||||
sleepMode = callServiceDyn (switch [EntityId "switch.adaptive_lighting_makuuhuoneen_valot_sleep_mode"] )
|
||||
cappedLightLevel :: HASS (Event Value) Bool
|
||||
cappedLightLevel = lightLevel >>> arr (< 4)
|
||||
|
||||
lightsOn =
|
||||
arr (\(o, capped, _, snap) -> (o, (capped, M.toList snap)))
|
||||
>>> first edge
|
||||
>>> arr (\(ev, p) -> tag p ev)
|
||||
>>|| callServicesDyn "Turn on lights (capped)" (\(c,xs) -> concatMap (uncurry (toLight c)) xs)
|
||||
|
||||
lightsSleep =
|
||||
arr (\(o, _, st, _) -> (not o, st))
|
||||
>>> first edge
|
||||
>>> arr (\(ev, st) -> tag st ev)
|
||||
>>> filterEvent anyLightsAreOn
|
||||
>>|| callService "Turn on sleep" (activateScene "scene.makuuhuone_lepotila")
|
||||
|
||||
lightsOff =
|
||||
arr (\(o, _, _, _) -> not o)
|
||||
>>> waitFor 300
|
||||
>>|| callService "Turn off lights" (light bedroomLightTargets [] Off)
|
||||
|
||||
anyLightsAreOn :: Foldable f => f LightObservation -> Bool
|
||||
anyLightsAreOn = any observedOn
|
||||
toLight :: Bool -> T.Text -> LightObservation -> [Service]
|
||||
toLight _ entityId LightObservation{observedOn=False} = [light [EntityId entityId] [] Off]
|
||||
toLight capped entityId LightObservation{observedOn=True, observedTemperature=t, observedBrightness=b} =
|
||||
[ light [EntityId entityId] [] (On def
|
||||
{lightBrightness = fmap (\b' -> BrightnessAbsolute $ if capped then 140 `min` b' else b') b
|
||||
, lightColorTemperature = t
|
||||
})
|
||||
]
|
||||
|
||||
|
||||
data BedroomControls
|
||||
= Masse (IkeaButton IkeaGesture)
|
||||
| Enishen (IkeaButton IkeaGesture)
|
||||
| Central IkeaController
|
||||
| Central IkeaRemoteAction
|
||||
deriving Show
|
||||
|
||||
|
||||
bedroomButton :: HASS (Event Value) (Event BedroomControls)
|
||||
bedroomButton = (masseButton &&& enishenButton &&& centralButton)
|
||||
>>> arr (\(a,(b,c)) -> a `lMerge` b `lMerge` c)
|
||||
>>> arr (\(a,(b,c)) -> a <> b <> c)
|
||||
where
|
||||
masseButton = fmap Masse <$> ikeaQuickButton "event.bedroom_quick_remote_masse_action"
|
||||
enishenButton = fmap Enishen <$> ikeaQuickButton "event.bedroom_quick_jemina_action"
|
||||
@@ -87,20 +124,29 @@ bedroomButtonController = proc x -> do
|
||||
ev <- bedroomButton >>> traceEvent -< x
|
||||
-- Any event will cause the sleep mode to be turned off
|
||||
case ev of
|
||||
Event _ -> sleepMode -< False
|
||||
Event (Masse (OnButton ShortRelease)) -> do
|
||||
callService "scene.makuuhuone_masse" (activateScene "scene.makuuhuone_masse") -< ()
|
||||
Event (Masse (OnButton DoubleClick)) -> do
|
||||
callService "scene.makuuhuone_keski" (activateScene "scene.makuuhuone_keski") -< ()
|
||||
Event (Masse (OnButton LongClick)) -> do
|
||||
callService "scene.makuuhuone_kirkas" (activateScene "scene.makuuhuone_kirkas") -< ()
|
||||
Event (Masse (OffButton LongClick)) -> do
|
||||
callService "Lights off" (light [AreaId "makuuhuone"] [] Off) -< ()
|
||||
callService "Hallway lights off" (light [EntityId "light.hallway_lights"] [] Off) -< ()
|
||||
Event (Masse (OffButton _)) -> do
|
||||
callService "Lights off" (light [AreaId "makuuhuone"] [] Off) -< ()
|
||||
Event (Enishen (OnButton ShortRelease)) -> do
|
||||
callService "scene.makuuhuone_jemina" (activateScene "scene.makuuhuone_jemina") -< ()
|
||||
Event (Enishen (OnButton DoubleClick)) -> do
|
||||
callService "scene.makuuhuone_keski" (activateScene "scene.makuuhuone_keski") -< ()
|
||||
Event (Enishen (OnButton LongClick)) -> do
|
||||
callService "scene.makuuhuone_kirkas" (activateScene "scene.makuuhuone_kirkas") -< ()
|
||||
Event (Enishen (OffButton LongClick)) -> do
|
||||
callService "Lights off" (light [AreaId "makuuhuone"] [] Off) -< ()
|
||||
callService "Hallway lights off" (light [EntityId "light.hallway_lights"] [] Off) -< ()
|
||||
Event (Enishen (OffButton _)) -> do
|
||||
callService "Lights off" (light [AreaId "makuuhuone"] [] Off) -< ()
|
||||
_ -> returnA -< ()
|
||||
case ev of
|
||||
Event (Masse (OnButton ShortRelease)) -> callService (activateScene "scene.makuuhuone_masse") -< ()
|
||||
Event (Masse (OnButton DoubleClick)) -> callService (activateScene "scene.makuuhuone_keski") -< ()
|
||||
Event (Masse (OnButton LongClick)) -> callService (activateScene "scene.makuuhuone_kirkas") -< ()
|
||||
Event (Masse (OffButton _)) -> callService (light [AreaId "makuuhuone"] Off) -< ()
|
||||
Event (Enishen (OnButton ShortRelease)) -> callService (activateScene "scene.makuuhuone_jemina") -< ()
|
||||
Event (Enishen (OnButton DoubleClick)) -> callService (activateScene "scene.makuuhuone_keski") -< ()
|
||||
Event (Enishen (OnButton LongClick)) -> callService (activateScene "scene.makuuhuone_kirkas") -< ()
|
||||
Event (Enishen (OffButton _)) -> callService (light [AreaId "makuuhuone"] Off) -< ()
|
||||
_ -> returnA -< ()
|
||||
where
|
||||
sleepMode = callServiceDyn (switch [EntityId "switch.adaptive_lighting_makuuhuoneen_valot_sleep_mode"] )
|
||||
|
||||
|
||||
|
||||
@@ -109,22 +155,21 @@ drawer = entityBool "binary_sensor.bedroom_nightstand_drawer_sensor_masse_contac
|
||||
>>> arr (fmap (bool Closed Open))
|
||||
|
||||
bedroomDrawerController :: HASS (Event Value) ()
|
||||
bedroomDrawerController = proc x -> do
|
||||
st <- drawer >>> traceEvent -< x
|
||||
case st of
|
||||
Event Open -> callService (switch [entity] True) -< ()
|
||||
Event Closed -> callService (switch [entity] False) -< ()
|
||||
_ -> returnA -< ()
|
||||
bedroomDrawerController =
|
||||
drawer >>>
|
||||
(named "Drawer opened" lightOn <> named "Drawer closed" lightOff)
|
||||
>>> arr (const ())
|
||||
where
|
||||
entity = EntityId "switch.bedroom_drawer_light_masse"
|
||||
lightOff = filterEvent (== Closed)
|
||||
>>|| callService "drawer light off" (switchService [entity] [] False)
|
||||
lightOn = filterEvent (== Open)
|
||||
>>|| callService "drawer light on" (switchService [entity] [] True)
|
||||
|
||||
door :: HASS (Event Value) (Event DoorState)
|
||||
door = entityBool "binary_sensor.makuuhuone_ovi_contact"
|
||||
>>> arr (fmap (bool Closed Open))
|
||||
|
||||
waitFor :: NominalDiffTime -> HASS a (Event ())
|
||||
waitFor n = duration >>> arr (> n) >>> edge
|
||||
|
||||
|
||||
delayedDoor :: HASS (Event Value) (Event DoorState)
|
||||
delayedDoor = door
|
||||
@@ -138,8 +183,8 @@ humidifierController = proc x -> do
|
||||
case st of
|
||||
-- Turn the humidifier on when the door is closed
|
||||
-- the humidifier is low-powered, no point in losing all the humidity
|
||||
Event Open -> callService (humidifier False) -< ()
|
||||
Event Closed -> callService (humidifier True) -< ()
|
||||
Event Open -> callService "Humidifier off" (humidifier False) -< ()
|
||||
Event Closed -> callService "Humidifier on" (humidifier True) -< ()
|
||||
_ -> returnA -< ()
|
||||
where
|
||||
humidifier state = Service
|
||||
@@ -147,4 +192,5 @@ humidifierController = proc x -> do
|
||||
, serviceName= bool "turn_off" "turn_on" state
|
||||
, serviceData= Nothing
|
||||
, serviceTarget= [EntityId "humidifier.makuuhuone_ilmankostutin"]
|
||||
, serviceExclusions= []
|
||||
}
|
||||
@@ -1,14 +1,25 @@
|
||||
{-# LANGUAGE Arrows #-}
|
||||
{-# LANGUAGE OverloadedStrings #-}
|
||||
{-# LANGUAGE DerivingVia #-}
|
||||
module HomeAssistant.Controller.Children where
|
||||
import HomeAssistant.Controller (HASS, callService, Target (AreaId), light, Light(..), ikeaQuickButton, IkeaGesture (..), IkeaButton (..), traceEvent, activateScene)
|
||||
import HomeAssistant.Controller (HASS, callService, light, LightCommand(..), ikeaQuickButton, IkeaGesture (..), IkeaButton (..), traceEvent, activateScene, LightAttributes (..), Brightness (..), entityRead, entityChangeEvent)
|
||||
import AFRP (Event (..))
|
||||
import qualified AFRP
|
||||
import Control.Arrow (Arrow(..), (>>>), returnA)
|
||||
import Data.Time (Day, TimeOfDay (..), localDay, LocalTime (..))
|
||||
import Data.Time.Calendar.OrdinalDate (WeekOfYear, mondayStartWeek)
|
||||
import Data.Functor.Contravariant (Predicate (..), (>$<))
|
||||
import Data.Aeson (Value)
|
||||
import Data.Aeson (Value, object, (.=))
|
||||
import Data.Default (Default(..))
|
||||
import Data.Serialize (Serialize)
|
||||
import Data.Serialize.Text ()
|
||||
import GHC.Generics (Generic)
|
||||
import HomeAssistant.Controller.Service (Service(..), Target(..))
|
||||
import Data.Aeson.Types (ToJSON (..))
|
||||
import Data.Aeson.Lens (key, _String)
|
||||
import Control.Lens ((^?), to)
|
||||
import Data.Text (Text)
|
||||
import Control.Monad (join)
|
||||
|
||||
-- Let's see building some reasonable interface for utctime
|
||||
dow :: Day -> (WeekOfYear, Int)
|
||||
@@ -49,7 +60,6 @@ timersOff =
|
||||
, day 3 <> at (08,15)
|
||||
, day 4 <> at (08,15)
|
||||
, day 5 <> at (08,15)
|
||||
, at (18,57) -- debug
|
||||
]
|
||||
where
|
||||
dayOfWeek = snd . mondayStartWeek . localDay
|
||||
@@ -75,22 +85,84 @@ schoolLightController = lightsOn <> lightsOff
|
||||
|
||||
lightsOn :: HASS a ()
|
||||
lightsOn = foldMap atTime timersOn
|
||||
>>> AFRP.onEvent (callService (light [AreaId "lasten_makuuhuone"] On{brightnessPercentage = Just 100}))
|
||||
>>> AFRP.onEvent (callService "Lights on" lights)
|
||||
where
|
||||
lights = light [AreaId "lasten_makuuhuone"] [] (On def{lightBrightness=Just (BrightnessPercent 100), lightTransition = Just 5} )
|
||||
|
||||
lightsOff :: HASS a ()
|
||||
lightsOff = foldMap atTime timersOff
|
||||
>>> AFRP.onEvent (callService (light [AreaId "lasten_makuuhuone"] Off))
|
||||
>>> AFRP.onEvent (callService "Lights off" (light [AreaId "lasten_makuuhuone"] [LabelId "decoration"] Off))
|
||||
|
||||
|
||||
bedroomButton :: HASS (Event Value) (Event (IkeaButton IkeaGesture))
|
||||
bedroomButton = ikeaQuickButton "event.children_quick_remote_action"
|
||||
childrenBedroomButton :: HASS (Event Value) (Event (IkeaButton IkeaGesture))
|
||||
childrenBedroomButton = ikeaQuickButton "event.children_quick_remote_action"
|
||||
|
||||
childrenBedroomButtonController :: HASS (Event Value) ()
|
||||
childrenBedroomButtonController = proc x -> do
|
||||
ev <- bedroomButton >>> traceEvent -< x
|
||||
ev <- childrenBedroomButton >>> traceEvent -< x
|
||||
case ev of
|
||||
Event (OnButton ShortRelease) -> callService (activateScene "scene.lasten_nukkuvalmistelu") -< ()
|
||||
Event (OnButton DoubleClick) -> callService (activateScene "scene.lasten_luku") -< ()
|
||||
Event (OnButton LongClick) -> callService (activateScene "scene.lasten_kirkas") -< ()
|
||||
Event (OffButton _) -> callService (light [AreaId "lasten_makuuhuone"] Off) -< ()
|
||||
Event (OnButton ShortRelease) -> callService "scene.lasten_nukkuvalmistelu" (activateScene "scene.lasten_nukkuvalmistelu") -< ()
|
||||
Event (OnButton DoubleClick) -> callService "scene.lasten_luku" (activateScene "scene.lasten_luku") -< ()
|
||||
Event (OnButton LongClick) -> callService "scene.lasten_kirkas" (activateScene "scene.lasten_kirkas") -< ()
|
||||
Event (OffButton _) -> callService "Lights off" (light [AreaId "lasten_makuuhuone"] [LabelId "decoration"] Off) -< ()
|
||||
_ -> returnA -< ()
|
||||
|
||||
newtype PM25 = PM25 Float
|
||||
deriving (Serialize, Eq, Ord) via Float
|
||||
deriving Show
|
||||
|
||||
data PM25Level = PM25High | PM25Low
|
||||
deriving (Eq, Generic, Show)
|
||||
|
||||
instance Serialize PM25Level
|
||||
|
||||
pm25 :: HASS (Event Value) PM25
|
||||
pm25 = fmap PM25 (entityRead "sensor.children_temp_pm25" >>> AFRP.hold 0)
|
||||
|
||||
pm25Level :: HASS PM25 PM25Level
|
||||
pm25Level = (tagHigh &&& tagLow) >>> arr (uncurry AFRP.lMerge) >>> AFRP.hold PM25Low
|
||||
where
|
||||
-- Band between 8 and 12 to avoid oscillation near the ~10 mark
|
||||
tagHigh = arr (> PM25 12) >>> AFRP.edge >>> arr (AFRP.tag PM25High)
|
||||
tagLow = arr (< PM25 8) >>> AFRP.edge >>> arr (AFRP.tag PM25Low)
|
||||
|
||||
data HumidifierAction
|
||||
= Idle
|
||||
| Humidifying
|
||||
| Other Text
|
||||
deriving (Show, Eq, Generic)
|
||||
instance Serialize HumidifierAction
|
||||
|
||||
-- what is the humidifer doing right now?
|
||||
humidifierOperatingState :: HASS (Event Value) (Event (Maybe HumidifierAction))
|
||||
humidifierOperatingState = entityChangeEvent "humidifier.lapset_ilmankostutin"
|
||||
>>> arr (fmap entityAction)
|
||||
where
|
||||
entityAction v = v ^? key "event" . key "variables" . key "trigger" . key "to_state" . key "attributes" . key "action" . _String . to humidifierAction
|
||||
humidifierAction = \case
|
||||
"idle" -> Idle
|
||||
"humidifying" -> Humidifying
|
||||
other -> Other other
|
||||
|
||||
-- TODO: There's some other percentages elsewhere that could be replaced with this
|
||||
newtype Percentage = Percentage Int
|
||||
instance ToJSON Percentage where
|
||||
toJSON (Percentage p) = object ["percentage" .= p]
|
||||
|
||||
childrenAirFilterController :: HASS (Event Value) ()
|
||||
childrenAirFilterController = proc ev -> do
|
||||
level <- pm25 >>> pm25Level >>> AFRP.changes >>> traceEvent -< ev
|
||||
humidifier <- humidifierOperatingState >>> AFRP.holdKnown >>> arr join -< ev
|
||||
case level of
|
||||
Event PM25High ->
|
||||
AFRP.whenA (== Just Idle) (callService "Fan strong" (fanOnTo (Percentage 80))) -< humidifier
|
||||
Event PM25Low -> callService "Fan low" (fanOnTo (Percentage 20)) -< ()
|
||||
_ -> returnA -< ()
|
||||
where
|
||||
fanOnTo percentage = Service
|
||||
{ serviceDomain = "fan"
|
||||
, serviceName = "set_percentage"
|
||||
, serviceTarget = [EntityId "fan.children_fan"]
|
||||
, serviceExclusions = []
|
||||
, serviceData = Just $ toJSON percentage
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
module HomeAssistant.Controller.Door (DoorState(..), doorState) where
|
||||
|
||||
import GHC.Generics (Generic)
|
||||
import Data.Serialize (Serialize)
|
||||
import AFRP (Mealy, Event)
|
||||
import Data.Aeson (Value)
|
||||
import Data.Text (Text)
|
||||
import HomeAssistant.Controller.Entity (entityBool)
|
||||
import Control.Arrow ((>>>), arr)
|
||||
import Data.Bool (bool)
|
||||
|
||||
data DoorState = Open | Closed
|
||||
deriving (Show, Eq, Generic)
|
||||
|
||||
instance Serialize DoorState
|
||||
|
||||
doorState :: Text -> Mealy eff (Event Value) (Event DoorState)
|
||||
doorState entity = entityBool entity >>> arr (fmap (bool Closed Open))
|
||||
@@ -0,0 +1,60 @@
|
||||
{-# LANGUAGE Arrows #-}
|
||||
{-# LANGUAGE GADTs #-}
|
||||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
module HomeAssistant.Controller.Effect
|
||||
( HASSEff(..)
|
||||
, HASS
|
||||
, callService
|
||||
, callServices
|
||||
, callServiceDyn
|
||||
, callServicesDyn
|
||||
, debug
|
||||
, traceEvent
|
||||
, traceValue
|
||||
) where
|
||||
|
||||
import AFRP (Mealy, eff, Event (..), Request, named)
|
||||
import Control.Arrow (returnA)
|
||||
import HomeAssistant.Controller.Service (Service (..))
|
||||
import qualified Data.Text as T
|
||||
|
||||
data HASSEff a where
|
||||
CallService :: Request -> Service -> HASSEff ()
|
||||
CallServices :: Request -> [Service] -> HASSEff ()
|
||||
Debug :: Show a => a -> HASSEff ()
|
||||
Trace :: Show a => Request -> a -> HASSEff ()
|
||||
|
||||
type HASS a b = Mealy HASSEff a b
|
||||
|
||||
serviceLabel :: T.Text -> HASS a b -> HASS a b
|
||||
serviceLabel lbl = named ("Service: " <> lbl)
|
||||
|
||||
callService :: T.Text -> Service -> HASS a ()
|
||||
callService lbl service = serviceLabel lbl $ eff (\req _ -> CallService req service)
|
||||
|
||||
callServices :: T.Text -> [Service] -> HASS a ()
|
||||
callServices lbl service = serviceLabel lbl $ eff (\req _ -> CallServices req service)
|
||||
|
||||
callServiceDyn :: T.Text -> (a -> Service) -> HASS a ()
|
||||
callServiceDyn lbl mkService = serviceLabel lbl $ eff (\req a -> CallService req (mkService a))
|
||||
|
||||
callServicesDyn :: T.Text -> (a -> [Service]) -> HASS a ()
|
||||
callServicesDyn lbl mkService = serviceLabel lbl $ eff (\req a -> CallServices req (mkService a))
|
||||
|
||||
debug :: Show a => HASS a a
|
||||
debug = proc x -> do
|
||||
eff (const Debug) -< x
|
||||
returnA -< x
|
||||
|
||||
traceEvent :: Show a => HASS (Event a) (Event a)
|
||||
traceEvent = proc ev -> do
|
||||
case ev of
|
||||
Event a -> eff Trace -< a
|
||||
Tick -> returnA -< ()
|
||||
returnA -< ev
|
||||
|
||||
traceValue :: Show a => HASS a a
|
||||
traceValue = proc x -> do
|
||||
eff Trace -< x
|
||||
returnA -< x
|
||||
@@ -0,0 +1,51 @@
|
||||
{-# LANGUAGE LambdaCase #-}
|
||||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
module HomeAssistant.Controller.Entity
|
||||
( entityChangeEvent
|
||||
, entityChangeEvent'
|
||||
, entityRead
|
||||
, entityRead'
|
||||
, entityBool
|
||||
, entityBool'
|
||||
) where
|
||||
|
||||
import AFRP (Mealy (..), Event, events, filterA, (>>|), toEvent, named)
|
||||
import Control.Arrow (arr)
|
||||
import Control.Category ((>>>))
|
||||
import Data.Aeson (Value)
|
||||
import Data.Aeson.Lens (key, _String)
|
||||
import qualified Data.Text as T
|
||||
import qualified Data.Set as S
|
||||
import Control.Lens (has, only, (^?), to)
|
||||
import qualified Data.Text.Lens as TL
|
||||
import AFRP.Diagram (emptyDiagram)
|
||||
|
||||
entityChangeEvent :: T.Text -> Mealy eff (Event Value) (Event Value)
|
||||
entityChangeEvent entityId = entityChangeEvent' entityId >>> toEvent
|
||||
|
||||
entityChangeEvent' :: T.Text -> Mealy eff (Event Value) (Either () Value)
|
||||
entityChangeEvent' entityId = named entityId $ Mealy (S.singleton entityId) emptyDiagram $ runMealy (events >>| filterA isEntity)
|
||||
where
|
||||
isEntity :: Value -> Bool
|
||||
isEntity = has (key "event" . key "variables" . key "trigger" . key "entity_id" . _String . only entityId)
|
||||
|
||||
entityRead' :: (Read a) => T.Text -> Mealy eff (Event Value) (Either () a)
|
||||
entityRead' entityId = entityChangeEvent' entityId >>| (arr state >>> arr (maybe (Left ()) Right))
|
||||
where
|
||||
state v = v ^? key "event" . key "variables" . key "trigger" . key "to_state" . key "state" . _String . TL.unpacked . to read
|
||||
|
||||
entityBool' :: T.Text -> Mealy eff (Event Value) (Either () Bool)
|
||||
entityBool' entityId = entityChangeEvent' entityId >>| (arr state >>> arr (maybe (Left ()) Right))
|
||||
where
|
||||
state v = v ^? key "event" . key "variables" . key "trigger" . key "to_state" . key "state" . _String . TL.unpacked . to toBool
|
||||
toBool = \case
|
||||
"on" -> True
|
||||
"off" -> False
|
||||
_ -> False
|
||||
|
||||
entityRead :: (Read a) => T.Text -> Mealy eff (Event Value) (Event a)
|
||||
entityRead entityId = entityRead' entityId >>> toEvent
|
||||
|
||||
entityBool :: T.Text -> Mealy eff (Event Value) (Event Bool)
|
||||
entityBool entityId = entityBool' entityId >>> toEvent
|
||||
@@ -1,38 +1,100 @@
|
||||
{-# LANGUAGE OverloadedStrings #-}
|
||||
{-# LANGUAGE Arrows #-}
|
||||
{-# LANGUAGE StrictData #-}
|
||||
{-# LANGUAGE RecordWildCards #-}
|
||||
module HomeAssistant.Controller.Hallway where
|
||||
|
||||
import HomeAssistant.Controller (Presence (..), HASS, motion, motionToPresence, traceEvent, callServiceDyn, light, Target (..), Light (..))
|
||||
import HomeAssistant.Controller (Presence (..), HASS, motion, motionToPresence, callServiceDyn, light, Target (..), LightCommand (..), doorState, DoorState (..), callService)
|
||||
import HomeAssistant.Controller.Bedroom (readyForSleep)
|
||||
import AFRP (Event (..))
|
||||
import qualified AFRP
|
||||
import Data.Aeson (Value)
|
||||
import Control.Arrow ((>>>), Arrow (..), returnA)
|
||||
import Control.Arrow ((>>>), arr, returnA)
|
||||
import Data.Time (LocalTime(..), TimeOfDay (..))
|
||||
import Data.Default (def)
|
||||
import Data.Serialize (Serialize)
|
||||
import GHC.Generics (Generic)
|
||||
|
||||
data Mode
|
||||
= Quiet -- ^ Possibly sleep time, doors are open, minimize light leakage
|
||||
| Regular -- ^ Doors are closed, light leakage is not a concern
|
||||
deriving (Generic, Eq, Show)
|
||||
|
||||
instance Serialize Mode
|
||||
|
||||
data ModeInput = ModeInput
|
||||
{ roomTimeOfDay :: TimeOfDay
|
||||
, bedroomDoor :: Maybe DoorState
|
||||
, childrenBedroomDoor :: Maybe DoorState
|
||||
, bedroomReadyForSleep :: Bool
|
||||
}
|
||||
|
||||
mode :: HASS (Event Value) Mode
|
||||
mode = roomState >>> arr sleepMode
|
||||
where
|
||||
sleepMode :: ModeInput -> Mode
|
||||
sleepMode ModeInput{..} = sleep
|
||||
where
|
||||
-- An open parents' bedroom door only leaks into someone's sleep while
|
||||
-- that someone is actually ready to sleep; an open door into an
|
||||
-- empty or awake room does not need the hallway dimmed.
|
||||
bedroomForLeakage = case bedroomDoor of
|
||||
Just Open | not bedroomReadyForSleep -> Just Closed
|
||||
door -> door
|
||||
sleep
|
||||
| Just Closed <- bedroomForLeakage, Just Closed <- childrenBedroomDoor = Regular
|
||||
| roomTimeOfDay > TimeOfDay 20 30 0 || roomTimeOfDay < TimeOfDay 7 30 0 = Quiet
|
||||
| otherwise = Regular
|
||||
roomState = ModeInput <$> timeOfDay <*> masterBedroom <*> childrenBedroom <*> readyForSleep
|
||||
timeOfDay = fmap localTimeOfDay AFRP.currentTime
|
||||
masterBedroom = doorState "binary_sensor.makuuhuone_ovi_contact" >>> AFRP.holdKnown
|
||||
childrenBedroom = doorState "binary_sensor.lasten_makuuhuone_ovi_contact" >>> AFRP.holdKnown
|
||||
|
||||
hallwayPresence :: HASS (Event Value) Presence
|
||||
hallwayPresence = motion "binary_sensor.hallway_movement_occupancy" >>> motionToPresence 500
|
||||
|
||||
data Lights = LightsOn | LightsOff
|
||||
deriving (Show)
|
||||
|
||||
eventLights :: HASS Presence (Event Lights)
|
||||
eventLights = AFRP.changes >>> arr (fmap presenceLights)
|
||||
lightsOnTrigger :: HASS (Event Value) (Event ())
|
||||
lightsOnTrigger = hallwayPresence >>> arr (== Occupied) >>> AFRP.edge
|
||||
|
||||
modeTrigger :: HASS (Event Value) (Event Mode)
|
||||
modeTrigger = ((,) <$> hallwayPresence <*> (mode >>> AFRP.changes)) >>> arr go
|
||||
where
|
||||
presenceLights Occupied = LightsOn
|
||||
presenceLights Unoccupied = LightsOff
|
||||
go (Unoccupied, _) = Tick
|
||||
go (Occupied, e) = e
|
||||
|
||||
modeC :: HASS (Event Value) ()
|
||||
modeC = modeTrigger >>> mconcat
|
||||
[ AFRP.filterEvent (== Quiet) AFRP.>>|| lightOff
|
||||
, AFRP.filterEvent (== Regular) AFRP.>>|| lightOn
|
||||
] >>>
|
||||
arr (const ())
|
||||
where
|
||||
lightOff = callService "Lower light off" (light [EntityId "light.hallway_ceiling"] [] Off)
|
||||
lightOn = callService "Lower light back on" (light [EntityId "light.hallway_ceiling"] [] (On def))
|
||||
|
||||
onC :: HASS (Event Value) ()
|
||||
onC = proc ev -> do
|
||||
trigger <- lightsOnTrigger -< ev
|
||||
m <- mode -< ev
|
||||
let entities = case m of
|
||||
Quiet -> [EntityId "light.hallway_ceiling_2"]
|
||||
Regular -> [EntityId "light.hallway_lights"]
|
||||
case trigger of
|
||||
Event _ -> lightsOn -< entities
|
||||
Tick -> returnA -< ()
|
||||
where
|
||||
lightsOn = callServiceDyn "Lights on" (\es -> light es [] (On def))
|
||||
|
||||
lightsOffTrigger :: HASS (Event Value) (Event ())
|
||||
lightsOffTrigger = hallwayPresence >>> arr (== Unoccupied) >>>
|
||||
AFRP.edgeFrom True -- we start from 'edgeFrom True' because the initial state is to be unoccupied
|
||||
|
||||
offC :: HASS (Event Value) ()
|
||||
offC = (lightsOffTrigger AFRP.>>|| lightsOff) >>>
|
||||
arr (const ())
|
||||
where
|
||||
lightsOff = callService "Lights off" (light [EntityId "light.hallway_lights"] [] Off)
|
||||
|
||||
hallwayLightsController :: HASS (Event Value) ()
|
||||
hallwayLightsController = proc x -> do
|
||||
now <- AFRP.currentTime -< ()
|
||||
p <- hallwayPresence -< x
|
||||
ev <- eventLights -< p
|
||||
traceEvent -< ev
|
||||
case ev of
|
||||
-- The lights entity is a "group of lights" in hass
|
||||
Event LightsOn | lightsAllowed now -> callServiceDyn (light [EntityId "light.hallway_lights"]) -< On Nothing
|
||||
Event LightsOff -> callServiceDyn (light [EntityId "light.hallway_lights"]) -< Off
|
||||
_ -> returnA -< ()
|
||||
where
|
||||
lightsAllowed (LocalTime _ tod) = not (tod > TimeOfDay 1 45 0 && tod < TimeOfDay 5 0 0)
|
||||
hallwayLightsController = onC <> offC <> modeC
|
||||
@@ -0,0 +1,80 @@
|
||||
{-# LANGUAGE LambdaCase #-}
|
||||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
module HomeAssistant.Controller.Ikea
|
||||
( IkeaGesture(..)
|
||||
, IkeaButton(..)
|
||||
, IkeaRemoteAction(..)
|
||||
, ikeaQuickButton
|
||||
, ikeaBoxRemote
|
||||
) where
|
||||
|
||||
import AFRP (Event, toEvent, (>>|))
|
||||
import Control.Arrow (arr)
|
||||
import Control.Category ((>>>))
|
||||
import Control.Lens ((^?), to, traversed)
|
||||
import Data.Aeson (Value)
|
||||
import Data.Aeson.Lens (key, _String)
|
||||
import qualified Data.Text as T
|
||||
import HomeAssistant.Controller.Entity (entityChangeEvent')
|
||||
import HomeAssistant.Controller.Effect (HASS)
|
||||
|
||||
data IkeaGesture
|
||||
= ShortClick
|
||||
| ShortRelease
|
||||
| DoubleClick
|
||||
| LongClick
|
||||
deriving Show
|
||||
|
||||
data IkeaButton a = OnButton !a | OffButton !a
|
||||
deriving Show
|
||||
|
||||
|
||||
toIkeaQuickButton :: T.Text -> Maybe (IkeaButton IkeaGesture)
|
||||
toIkeaQuickButton = \case
|
||||
-- 1 is on, 2 is off side of the button
|
||||
"1_initial_press" -> Just $ OnButton ShortClick
|
||||
"1_short_release" -> Just $ OnButton ShortRelease
|
||||
"1_double_press" -> Just $ OnButton DoubleClick
|
||||
"1_long_press" -> Just $ OnButton LongClick
|
||||
"2_initial_press" -> Just $ OffButton ShortClick
|
||||
"2_short_release" -> Just $ OffButton ShortRelease
|
||||
"2_double_press" -> Just $ OffButton DoubleClick
|
||||
"2_long_press" -> Just $ OffButton LongClick
|
||||
_ -> Nothing
|
||||
|
||||
ikeaQuickButton :: T.Text -> HASS (Event Value) (Event (IkeaButton IkeaGesture))
|
||||
ikeaQuickButton entityId =
|
||||
entityChangeEvent' entityId
|
||||
>>| arr (maybe (Left ()) Right . eventType)
|
||||
>>> toEvent
|
||||
where
|
||||
eventType v = v ^? key "event" . key "variables" . key "trigger" . key "to_state" . key "attributes" . key "event_type" . _String . to toIkeaQuickButton . traversed
|
||||
|
||||
data IkeaRemoteAction
|
||||
= RemoteOn -- Short press on
|
||||
| RemoteOff -- Short press off
|
||||
| RemoteBrightnessUp -- Turn brightness up
|
||||
| RemoteBrightnessDown -- Turn brightness down
|
||||
| RemoteArrowRight -- Arrow right
|
||||
| RemoteArrowLeft -- Arrow left
|
||||
| RemoteBrightnessStop
|
||||
deriving Show
|
||||
|
||||
toIkeaRemoteAction :: T.Text -> Maybe IkeaRemoteAction
|
||||
toIkeaRemoteAction = \case
|
||||
"on" -> Just RemoteOn
|
||||
"off" -> Just RemoteOff
|
||||
"brightness_move_up" -> Just RemoteBrightnessUp
|
||||
"brightness_move_down" -> Just RemoteBrightnessDown
|
||||
"brightness_stop" -> Just RemoteBrightnessStop
|
||||
"arrow_right_click" -> Just RemoteArrowRight
|
||||
"arrow_left_click" -> Just RemoteArrowLeft
|
||||
_ -> Nothing
|
||||
|
||||
ikeaBoxRemote :: T.Text -> HASS (Event Value) (Event IkeaRemoteAction)
|
||||
ikeaBoxRemote entityId = entityChangeEvent' entityId
|
||||
>>| arr (maybe (Left ()) Right . eventType)
|
||||
>>> toEvent
|
||||
where
|
||||
eventType v = v ^? key "event" . key "variables" . key "trigger" . key "to_state" . key "attributes" . key "event_type" . _String . to toIkeaRemoteAction . traversed
|
||||
@@ -2,37 +2,29 @@
|
||||
{-# LANGUAGE Arrows #-}
|
||||
module HomeAssistant.Controller.Kitchen where
|
||||
import HomeAssistant.Controller
|
||||
import AFRP (Event (..))
|
||||
import AFRP (Event (..), (>>||))
|
||||
import qualified AFRP
|
||||
import Data.Aeson (Value)
|
||||
import Control.Arrow ((>>>), Arrow (..), returnA)
|
||||
import Prelude hiding (id)
|
||||
import Data.Time (LocalTime(..), TimeOfDay (..))
|
||||
import Data.Default (def)
|
||||
|
||||
|
||||
-- Kitchen has two "presence" sensors. One IKEA motion sensor and one SwitchBot presence sensor
|
||||
|
||||
data Lights = LightsOn | LightsOff | LightsSleep
|
||||
deriving (Show)
|
||||
|
||||
kitchenPresence :: HASS (Event Value) Presence
|
||||
kitchenPresence = motion "binary_sensor.kitchen_movement_occupancy" >>> motionToPresence 500
|
||||
|
||||
eventLights :: HASS Presence (Event Lights)
|
||||
eventLights = AFRP.changes >>> arr (fmap presenceLights)
|
||||
where
|
||||
presenceLights Occupied = LightsOn
|
||||
presenceLights Unoccupied = LightsOff
|
||||
|
||||
kitchenCeilingController :: HASS (Event Value) ()
|
||||
kitchenCeilingController = proc x -> do
|
||||
now <- AFRP.currentTime -< ()
|
||||
p <- kitchenPresence -< x
|
||||
ev <- eventLights -< p
|
||||
ev <- lightingModeEvents -< p
|
||||
traceEvent -< ev
|
||||
case ev of
|
||||
Event LightsOn | lightsAllowed now -> callServiceDyn (light [EntityId "light.kitchen_ceiling"]) -< On Nothing
|
||||
Event LightsOff -> callServiceDyn (light [EntityId "light.kitchen_ceiling"]) -< Off
|
||||
Event LightingOn | lightsAllowed now -> callServiceDyn "light.kitchen_ceiling on" (light [EntityId "light.kitchen_ceiling"] []) -< On def
|
||||
Event LightingOff -> callServiceDyn "light.kitchen_ceiling off" (light [EntityId "light.kitchen_ceiling"] []) -< Off
|
||||
_ -> returnA -< ()
|
||||
where
|
||||
lightsAllowed (LocalTime _ tod) = not (tod > TimeOfDay 1 45 0 && tod < TimeOfDay 5 0 0)
|
||||
@@ -44,44 +36,39 @@ dinnerLightLevel = entityRead "sensor.sijainti_keittio_light_level" >>> AFRP.hol
|
||||
dinnerPresence :: HASS (Event Value) Presence
|
||||
dinnerPresence = presence "binary_sensor.sijainti_keittio_occupancy" >>> AFRP.hold Unoccupied
|
||||
|
||||
dinnerLightEvents :: HASS (Event Value) (Event Lights)
|
||||
dinnerLightEvents =
|
||||
|
||||
dinnerTableController :: HASS (Event Value) ()
|
||||
dinnerTableController =
|
||||
((,) <$> dinnerLightLevel <*> dinnerPresence)
|
||||
>>> arr lightWanted
|
||||
>>> (sleepEvent &&& offEvent &&& onEvent)
|
||||
>>> arr (\(s, (o, n)) -> s `AFRP.lMerge` o `AFRP.lMerge` n)
|
||||
-- These are done "in parallel", there is a chance that two services are called in one go
|
||||
>>> mconcat
|
||||
[ AFRP.named "Lights on" lightsOn
|
||||
, AFRP.named "Lights sleep" lightsSleep
|
||||
, AFRP.named "Lights off" lightsOff ]
|
||||
>>> arr (const ()) -- I don't like this extra arr here
|
||||
where
|
||||
lightWanted (lightLevel, occ) = occ == Occupied && lightLevel < 13
|
||||
|
||||
onEvent =
|
||||
lightsOn =
|
||||
AFRP.edge
|
||||
>>> arr (fmap (const LightsOn))
|
||||
>>|| sleep "sleep off" False
|
||||
>>> callService "Dining light on" (light [EntityId "light.kitchen_dining_large"] [] $ On def)
|
||||
|
||||
sleepEvent =
|
||||
lightsSleep =
|
||||
arr not
|
||||
>>> AFRP.edge
|
||||
>>> arr (fmap (const LightsSleep))
|
||||
>>|| sleep "sleep on" True
|
||||
|
||||
offEvent =
|
||||
lightsOff =
|
||||
arr not
|
||||
>>> AFRP.waitFor 300
|
||||
>>> arr (fmap (const LightsOff))
|
||||
>>|| sleep "sleep off" False
|
||||
>>> callService "Dining light on" (light [EntityId "light.kitchen_dining_large"] [] Off)
|
||||
|
||||
|
||||
sleep lbl b = callService lbl (switchService [EntityId "switch.adaptive_lighting_ruokapoydan_valot_sleep_mode"] [] b)
|
||||
|
||||
dinnerTableController :: HASS (Event Value) ()
|
||||
dinnerTableController = proc x -> do
|
||||
ev <- dinnerLightEvents -< x
|
||||
case ev of
|
||||
Event LightsOn -> do
|
||||
sleep -< False
|
||||
callServiceDyn (light [EntityId "light.kitchen_dining_large"]) -< On Nothing
|
||||
Event LightsOff -> do
|
||||
sleep -< False
|
||||
callServiceDyn (light [EntityId "light.kitchen_dining_large"]) -< Off
|
||||
Event LightsSleep -> do
|
||||
sleep -< True
|
||||
_ -> returnA -< ()
|
||||
where
|
||||
sleep = callServiceDyn (switch [EntityId "switch.adaptive_lighting_ruokapoydan_valot_sleep_mode"])
|
||||
|
||||
kitchenMotionController :: HASS (Event Value) ()
|
||||
kitchenMotionController = kitchenCeilingController <> dinnerTableController
|
||||
@@ -0,0 +1,65 @@
|
||||
{-# LANGUAGE MonadComprehensions #-}
|
||||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
module HomeAssistant.Controller.Light.Command
|
||||
( LightCommand(..)
|
||||
, LightAttributes(..)
|
||||
, Brightness(..)
|
||||
, light
|
||||
, formatLightAttributes
|
||||
) where
|
||||
|
||||
import Data.Aeson (Value, object, (.=))
|
||||
import Data.Aeson.Types (Pair)
|
||||
import Data.Default (Default)
|
||||
import Data.Maybe (catMaybes)
|
||||
import GHC.Generics (Generic)
|
||||
import HomeAssistant.Controller.Service (Service (..), Target)
|
||||
|
||||
data Brightness = BrightnessPercent Double | BrightnessAbsolute Int
|
||||
deriving (Show, Generic)
|
||||
instance Default Brightness where
|
||||
|
||||
data LightAttributes = LightAttributes
|
||||
{ lightBrightness :: Maybe Brightness
|
||||
, lightColorTemperature :: Maybe Int
|
||||
, lightTransition :: Maybe Double
|
||||
}
|
||||
deriving (Show, Generic)
|
||||
|
||||
|
||||
instance Default LightAttributes where
|
||||
|
||||
|
||||
formatLightAttributes :: LightAttributes -> Maybe Value
|
||||
formatLightAttributes s = toObject $ catMaybes
|
||||
[ ["transition" .= x | x <- lightTransition s]
|
||||
, ["color_temp_kelvin" .= k | k <- lightColorTemperature s]
|
||||
, ["brightness" .= b | BrightnessAbsolute b <- lightBrightness s]
|
||||
, ["brightness_pct" .= b | BrightnessPercent b <- lightBrightness s]
|
||||
]
|
||||
where
|
||||
toObject :: [Pair] -> Maybe Value
|
||||
toObject [] = Nothing
|
||||
toObject xs = Just $ object xs
|
||||
|
||||
data LightCommand
|
||||
= Off
|
||||
| On LightAttributes
|
||||
|
||||
light :: [Target] -> [Target] -> LightCommand -> Service
|
||||
light targets exclusions = \case
|
||||
(On settings) -> Service
|
||||
{ serviceDomain="light"
|
||||
, serviceName= "turn_on"
|
||||
, serviceData= formatLightAttributes settings
|
||||
, serviceTarget=targets
|
||||
, serviceExclusions = exclusions
|
||||
}
|
||||
Off -> Service
|
||||
{ serviceDomain="light"
|
||||
, serviceName= "turn_off"
|
||||
, serviceData=Nothing
|
||||
, serviceTarget=targets
|
||||
, serviceExclusions = exclusions
|
||||
}
|
||||
@@ -0,0 +1,23 @@
|
||||
module HomeAssistant.Controller.Light.Mode
|
||||
( LightingMode(..)
|
||||
, toLightingMode
|
||||
, lightingModeEvents
|
||||
) where
|
||||
|
||||
import HomeAssistant.Controller.Effect (HASS)
|
||||
import HomeAssistant.Controller.Presence (Presence (..))
|
||||
import qualified AFRP
|
||||
import Control.Arrow (Arrow(..), (>>>))
|
||||
import GHC.Generics (Generic)
|
||||
import Data.Serialize (Serialize)
|
||||
|
||||
data LightingMode = LightingOn | LightingOff | LightingSleep
|
||||
deriving (Eq, Show, Generic)
|
||||
instance Serialize LightingMode
|
||||
|
||||
toLightingMode :: Presence -> LightingMode
|
||||
toLightingMode Occupied = LightingOn
|
||||
toLightingMode Unoccupied = LightingOff
|
||||
|
||||
lightingModeEvents :: HASS Presence (AFRP.Event LightingMode)
|
||||
lightingModeEvents = AFRP.changes >>> arr (fmap toLightingMode)
|
||||
@@ -0,0 +1,52 @@
|
||||
{-# LANGUAGE Arrows #-}
|
||||
{-# LANGUAGE OverloadedStrings #-}
|
||||
{-# LANGUAGE StrictData #-}
|
||||
|
||||
module HomeAssistant.Controller.Light.Observation
|
||||
( LightObservation(..)
|
||||
, observedLight
|
||||
, lightBrightnessEvent
|
||||
, lightTemperatureEvent
|
||||
) where
|
||||
|
||||
import AFRP (Event, hold)
|
||||
import Control.Arrow (arr, returnA)
|
||||
import Control.Category ((>>>), (.))
|
||||
import Control.Lens ((^?))
|
||||
import Data.Aeson (Value)
|
||||
import Data.Aeson.Lens (key, _Integral)
|
||||
import qualified Data.Text as T
|
||||
import GHC.Generics (Generic)
|
||||
import Data.Serialize (Serialize)
|
||||
import HomeAssistant.Controller.Entity (entityBool, entityChangeEvent)
|
||||
import HomeAssistant.Controller.Effect (HASS)
|
||||
import Prelude hiding ((.))
|
||||
|
||||
lightBrightnessEvent :: T.Text -> HASS (Event Value) (Event (Maybe Int))
|
||||
lightBrightnessEvent entityId =
|
||||
entityChangeEvent entityId
|
||||
>>> arr (fmap eventBrightness)
|
||||
where
|
||||
eventBrightness v = v ^? key "event" . key "variables" . key "trigger" . key "to_state" . key "attributes" . key "brightness" . _Integral
|
||||
|
||||
lightTemperatureEvent :: T.Text -> HASS (Event Value) (Event (Maybe Int))
|
||||
lightTemperatureEvent entityId =
|
||||
entityChangeEvent entityId
|
||||
>>> arr (fmap eventTemperature)
|
||||
where
|
||||
eventTemperature v = v ^? key "event" . key "variables" . key "trigger" . key "to_state" . key "attributes" . key "color_temp_kelvin" . _Integral
|
||||
|
||||
data LightObservation = LightObservation
|
||||
{ observedOn :: Bool
|
||||
, observedBrightness :: Maybe Int
|
||||
, observedTemperature :: Maybe Int
|
||||
}
|
||||
deriving (Show, Generic, Eq)
|
||||
instance Serialize LightObservation
|
||||
|
||||
observedLight :: T.Text -> HASS (Event Value) LightObservation
|
||||
observedLight entityId = proc ev -> do
|
||||
e <- hold False . entityBool entityId -< ev
|
||||
b <- hold Nothing . lightBrightnessEvent entityId -< ev
|
||||
t <- hold Nothing . lightTemperatureEvent entityId -< ev
|
||||
returnA -< LightObservation e b t
|
||||
@@ -2,25 +2,19 @@
|
||||
{-# LANGUAGE Arrows #-}
|
||||
module HomeAssistant.Controller.Livingroom where
|
||||
|
||||
import HomeAssistant.Controller (HASS, Presence (..), Target (..), presence, callServiceDyn, light, Light (..), traceEvent)
|
||||
import HomeAssistant.Controller (HASS, Presence (..), Target (..), presence, callServiceDyn, light, LightCommand (..), traceEvent, callService, activateScene)
|
||||
import HomeAssistant.Controller.Light.Mode (LightingMode (..), lightingModeEvents)
|
||||
import qualified AFRP
|
||||
import Control.Arrow ((>>>), Arrow (..), returnA)
|
||||
import Data.Aeson (Value)
|
||||
import Prelude hiding ((.))
|
||||
import Control.Category ((.))
|
||||
|
||||
data Lights = LightsOn | LightsOff
|
||||
deriving (Show)
|
||||
import Data.Time (LocalTime(..), toGregorian, TimeOfDay (..))
|
||||
import Data.Default (def)
|
||||
|
||||
livingroomPresence :: HASS (AFRP.Event Value) Presence
|
||||
livingroomPresence = presence "binary_sensor.occupancy_olohuone_derived" >>> AFRP.hold Unoccupied
|
||||
|
||||
eventLights :: HASS Presence (AFRP.Event Lights)
|
||||
eventLights = AFRP.changes >>> arr (fmap presenceLights)
|
||||
where
|
||||
presenceLights Occupied = LightsOn
|
||||
presenceLights Unoccupied = LightsOff
|
||||
|
||||
|
||||
-- There's a small race condition / corner case bug in the og implementation
|
||||
-- I have a couple of lights in the Livingroom
|
||||
@@ -37,15 +31,63 @@ eventLights = AFRP.changes >>> arr (fmap presenceLights)
|
||||
-- With that in mind, I'll be explicitly controlling the two lights, without any scene shenanigans
|
||||
|
||||
|
||||
lights :: [Target]
|
||||
lights = [EntityId "light.livingroom_ceiling", EntityId "light.livingroom_sofa"]
|
||||
livingroomLightTargets :: [Target]
|
||||
livingroomLightTargets = [EntityId "light.livingroom_ceiling", EntityId "light.livingroom_sofa"]
|
||||
|
||||
livingroomPresenceController :: HASS (AFRP.Event Value) ()
|
||||
livingroomPresenceController = proc x -> do
|
||||
ev <- eventLights . livingroomPresence -< x
|
||||
ev <- lightingModeEvents . livingroomPresence -< x
|
||||
traceEvent -< ev
|
||||
case ev of
|
||||
AFRP.Event LightsOn -> callServiceDyn (light lights) -< On Nothing
|
||||
AFRP.Event LightsOff -> callServiceDyn (light lights) -< Off
|
||||
AFRP.Event LightingOn -> callServiceDyn "Lights on" (light livingroomLightTargets []) -< On def
|
||||
AFRP.Event LightingOff -> callServiceDyn "Lights off" (light livingroomLightTargets []) -< Off
|
||||
_ -> returnA -< ()
|
||||
returnA -< ()
|
||||
|
||||
data Season = Summer | Fall | Winter | Spring
|
||||
deriving Show
|
||||
|
||||
|
||||
season :: HASS a Season
|
||||
season = AFRP.currentTime >>> arr toSeason
|
||||
where
|
||||
toSeason t =
|
||||
case toGregorian (localDay t) of
|
||||
(_, m, _)
|
||||
| m >= 12 || m <= 2 -> Winter
|
||||
| m <= 5 -> Spring
|
||||
| m <= 8 -> Summer
|
||||
| otherwise -> Fall
|
||||
|
||||
tod :: HASS a TimeOfDay
|
||||
tod = AFRP.currentTime >>> arr localTimeOfDay
|
||||
|
||||
data PlantLightMode = Growth | Ambience
|
||||
deriving Show
|
||||
|
||||
plantLightMode :: HASS (Season, TimeOfDay) (AFRP.Event PlantLightMode)
|
||||
plantLightMode =
|
||||
(lightMode &&& ambienceMode) >>> arr (uncurry AFRP.lMerge)
|
||||
where
|
||||
lightMode = arr (uncurry lightWanted) >>> AFRP.edge >>> arr (AFRP.tag Growth)
|
||||
ambienceMode = arr (uncurry ambienceWanted) >>> AFRP.edge >>> arr (AFRP.tag Ambience)
|
||||
-- Full brightness during daytime only non-summer
|
||||
lightWanted :: Season -> TimeOfDay -> Bool
|
||||
lightWanted Summer _ = False
|
||||
lightWanted _ TimeOfDay{todHour=10,todMin=00} = True
|
||||
lightWanted _ _ = False
|
||||
-- Ambience mode is always
|
||||
ambienceWanted :: Season -> TimeOfDay -> Bool
|
||||
ambienceWanted _ TimeOfDay{todHour=20,todMin=0} = True
|
||||
ambienceWanted _ _ = False
|
||||
|
||||
livingroomPlantLights :: HASS (AFRP.Event a) ()
|
||||
livingroomPlantLights = (season &&& tod)
|
||||
>>> plantLightMode
|
||||
>>> setLights
|
||||
where
|
||||
setLights = proc mode -> do
|
||||
case mode of
|
||||
AFRP.Event Growth -> callService "scene.olohuoneen_kasvivalo" (activateScene "scene.olohuoneen_kasvivalo") -< ()
|
||||
AFRP.Event Ambience -> callService "scene.kasvivalo_iltatila" (activateScene "scene.kasvivalo_iltatila") -< ()
|
||||
_ -> returnA -< ()
|
||||
@@ -0,0 +1,60 @@
|
||||
module HomeAssistant.Controller.Presence
|
||||
( Presence(..)
|
||||
, presence
|
||||
, Motion(..)
|
||||
, motion
|
||||
, motionEvent
|
||||
, motionToPresence
|
||||
) where
|
||||
|
||||
import AFRP (Event, hold, lMerge, waitFor, tag, edge, holdKnown)
|
||||
import Control.Arrow (arr, (&&&))
|
||||
import Control.Category ((>>>))
|
||||
import Data.Aeson (Value)
|
||||
import qualified Data.Text as T
|
||||
import Data.Bool (bool)
|
||||
import Data.Serialize (Serialize)
|
||||
import GHC.Generics (Generic)
|
||||
import Data.Time (NominalDiffTime)
|
||||
import HomeAssistant.Controller.Entity (entityBool)
|
||||
import HomeAssistant.Controller.Effect (HASS)
|
||||
|
||||
data Presence = Occupied | Unoccupied
|
||||
deriving (Show, Eq, Generic)
|
||||
|
||||
instance Serialize Presence
|
||||
|
||||
presence :: T.Text -> HASS (Event Value) (Event Presence)
|
||||
presence entityId = entityBool entityId
|
||||
>>> arr (fmap (bool Unoccupied Occupied))
|
||||
|
||||
|
||||
data Motion = MotionDetected | MotionNotDetected
|
||||
deriving (Show, Eq, Generic)
|
||||
|
||||
|
||||
motionEvent :: T.Text -> HASS (Event Value) (Event Motion)
|
||||
motionEvent entityId = entityBool entityId
|
||||
>>> arr (fmap (bool MotionNotDetected MotionDetected))
|
||||
|
||||
motion :: T.Text -> HASS (Event Value) (Maybe Motion)
|
||||
motion entityId = entityBool entityId
|
||||
>>> arr (fmap (bool MotionNotDetected MotionDetected))
|
||||
>>> holdKnown
|
||||
|
||||
|
||||
-- Convert a motion status into a simulated presence
|
||||
--
|
||||
-- A motion tracker detects _motion_, but if you are still, it can't detect you.
|
||||
-- A simple and cheap heuristic is to assume the person is a bit longer there
|
||||
motionToPresence :: NominalDiffTime -> HASS (Maybe Motion) Presence
|
||||
motionToPresence delay = (eventOccupied &&& eventUnoccupied)
|
||||
>>> arr (uncurry lMerge)
|
||||
>>> AFRP.hold Unoccupied
|
||||
where
|
||||
eventOccupied :: HASS (Maybe Motion) (Event Presence)
|
||||
eventOccupied = arr (== Just MotionDetected) >>> edge >>> arr (fmap (const Occupied))
|
||||
eventUnoccupied :: HASS (Maybe Motion) (Event Presence)
|
||||
eventUnoccupied = arr (== Just MotionNotDetected) >>> waitFor delay >>> arr (tag Unoccupied)
|
||||
|
||||
instance Serialize Motion
|
||||
@@ -1,4 +1,3 @@
|
||||
{-# LANGUAGE Arrows #-}
|
||||
{-# LANGUAGE OverloadedStrings #-}
|
||||
module HomeAssistant.Controller.Ruuvi
|
||||
( Ruuvi(..)
|
||||
|
||||
@@ -0,0 +1,22 @@
|
||||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
module HomeAssistant.Controller.Scene
|
||||
( activateScene
|
||||
, activateSceneWith
|
||||
) where
|
||||
|
||||
import Data.Aeson (Value)
|
||||
import qualified Data.Text as T
|
||||
import HomeAssistant.Controller.Service (Service (..), Target (..))
|
||||
|
||||
activateScene :: T.Text -> Service
|
||||
activateScene sceneId = activateSceneWith sceneId Nothing
|
||||
|
||||
activateSceneWith :: T.Text -> Maybe Value -> Service
|
||||
activateSceneWith sceneId d = Service
|
||||
{ serviceDomain="scene"
|
||||
, serviceName= "turn_on"
|
||||
, serviceTarget= [EntityId sceneId]
|
||||
, serviceData = d
|
||||
, serviceExclusions = []
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
module HomeAssistant.Controller.Service
|
||||
( Service(..)
|
||||
, Target(..)
|
||||
) where
|
||||
|
||||
import Data.Aeson (Value)
|
||||
import qualified Data.Text as T
|
||||
|
||||
data Target
|
||||
= EntityId !T.Text
|
||||
| AreaId !T.Text
|
||||
| LabelId !T.Text
|
||||
deriving (Show,Eq,Ord)
|
||||
|
||||
data Service = Service
|
||||
{ serviceDomain :: T.Text
|
||||
, serviceName :: T.Text
|
||||
, serviceData :: Maybe Value
|
||||
, serviceTarget :: [Target]
|
||||
, serviceExclusions :: [Target]
|
||||
}
|
||||
deriving (Show, Eq)
|
||||
@@ -0,0 +1,15 @@
|
||||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
module HomeAssistant.Controller.Switch (switchService) where
|
||||
|
||||
import Data.Bool (bool)
|
||||
import HomeAssistant.Controller.Service (Service (..), Target)
|
||||
|
||||
switchService :: [Target] -> [Target] -> Bool -> Service
|
||||
switchService targets exclusions b = Service
|
||||
{ serviceDomain="switch"
|
||||
, serviceName= bool "turn_off" "turn_on" b
|
||||
, serviceData=Nothing
|
||||
, serviceTarget=targets
|
||||
, serviceExclusions=exclusions
|
||||
}
|
||||
+100
-79
@@ -4,127 +4,148 @@
|
||||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
module HomeAssistant.Runtime
|
||||
( defaultMain
|
||||
, step
|
||||
, CallIdGen
|
||||
, mkCallIdGen
|
||||
, dryRunHassEval
|
||||
, Controller(..)
|
||||
, runController
|
||||
) where
|
||||
( defaultMain,
|
||||
step,
|
||||
CallIdGen,
|
||||
mkCallIdGen,
|
||||
dryRunHassEval,
|
||||
Controller (..),
|
||||
runController,
|
||||
)
|
||||
where
|
||||
|
||||
import AFRP (Event (..), Mealy (..), Request (..), Auto, stepAutoSerializing, load, DecodedAuto (..))
|
||||
import AFRP (Auto, DecodedAuto (..), Event (..), Mealy (..), Request (..), load, stepAutoSerializing)
|
||||
import Control.Concurrent.STM (atomically, dupTChan, readTChan)
|
||||
import Control.Monad.IO.Class (MonadIO, liftIO)
|
||||
import Data.Aeson (Value)
|
||||
import qualified Data.Text as T
|
||||
import Data.Foldable (forM_)
|
||||
import Data.Maybe (fromMaybe)
|
||||
import Data.Text qualified as T
|
||||
import Data.Time (getCurrentTime, getCurrentTimeZone)
|
||||
import Data.UUID (UUID, toText)
|
||||
import Data.UUID.V4 qualified as UUID.V4
|
||||
import Data.Void (Void)
|
||||
import GHC.Stack (HasCallStack)
|
||||
import HomeAssistant.Controller (HASS, HASSEff (..))
|
||||
import HomeAssistant.Controller.Bedroom (bedroomButtonController, bedroomDrawerController, bedroomPresenceController, humidifierController)
|
||||
import HomeAssistant.Controller.Children (childrenBedroomButtonController, schoolLightController, childrenAirFilterController)
|
||||
import HomeAssistant.Controller.Hallway (hallwayLightsController)
|
||||
import HomeAssistant.Controller.Kitchen (kitchenMotionController)
|
||||
import HomeAssistant.Controller.Livingroom (livingroomPlantLights, livingroomPresenceController)
|
||||
import HomeAssistant.Runtime.Bus
|
||||
import HomeAssistant.Runtime.Connection (writerAction, readerAction)
|
||||
import HomeAssistant.Runtime.Connection (readerAction, writerAction)
|
||||
import HomeAssistant.Runtime.Flags (loadFlags)
|
||||
import HomeAssistant.Runtime.Metrics qualified
|
||||
import HomeAssistant.Runtime.RateLimit (registerRateLimitMetrics, slidingWindowLimiter)
|
||||
import HomeAssistant.Runtime.Supervisor (supervised)
|
||||
import HttpServer qualified
|
||||
import Katip (KatipContext, Namespace (Namespace), Severity (..), logF, logLocM, ls, runKatipContextT, runKatipT, sl, katipAddNamespace)
|
||||
import Network.Socket (withSocketsDo)
|
||||
import System.Environment (getEnv, lookupEnv)
|
||||
import HomeAssistant.Controller.Bedroom (bedroomPresenceController, bedroomButtonController, bedroomDrawerController, humidifierController)
|
||||
import Data.UUID (UUID, toText)
|
||||
import qualified Data.UUID.V4 as UUID.V4
|
||||
import Katip (runKatipT, logF, sl, Severity (..), ls, Namespace (Namespace), runKatipContextT)
|
||||
import Control.Monad.IO.Class (liftIO, MonadIO)
|
||||
import HomeAssistant.Controller.Children (schoolLightController, childrenBedroomButtonController)
|
||||
import Data.Maybe (fromMaybe)
|
||||
import qualified System.Metrics
|
||||
import qualified HomeAssistant.Runtime.Metrics
|
||||
import System.FilePath ((</>))
|
||||
import System.FilePath ((</>), (<.>))
|
||||
import System.Metrics qualified
|
||||
import Text.Read (readMaybe)
|
||||
import HomeAssistant.Controller.Kitchen (kitchenMotionController)
|
||||
import HomeAssistant.Controller.Livingroom (livingroomPresenceController)
|
||||
import HomeAssistant.Runtime.RateLimit (slidingWindowLimiter, registerRateLimitMetrics)
|
||||
import UnliftIO.Async
|
||||
import HomeAssistant.Runtime.Supervisor (supervised)
|
||||
import qualified HomeAssistant.Runtime.Graphing
|
||||
import HomeAssistant.Controller.Hallway (hallwayLightsController)
|
||||
import Control.Monad.Catch (MonadCatch)
|
||||
import Control.Exception.Annotated (checkpoint, Annotation (..))
|
||||
import AFRP.Diagram (renderF)
|
||||
|
||||
step :: (MonadIO m) => FilePath -> UUID -> Auto m a b -> a -> m (b, Auto m a b)
|
||||
step path trace st a = do
|
||||
step :: (MonadIO m) => FilePath -> T.Text -> UUID -> Auto m a b -> a -> m (b, Auto m a b)
|
||||
step path name trace st a = do
|
||||
now <- liftIO getCurrentTime
|
||||
tz <- liftIO getCurrentTimeZone
|
||||
let req = Request now tz trace
|
||||
let req = Request now tz trace name
|
||||
stepAutoSerializing path st req a
|
||||
|
||||
data Controller = forall b. Controller Bool T.Text (HASS (Event Value) b)
|
||||
data Controller = forall b. Controller T.Text (HASS (Event Value) b)
|
||||
|
||||
controllers :: [Controller]
|
||||
controllers =
|
||||
[ Controller True "bedroom-presence" bedroomPresenceController
|
||||
, Controller True "bedroom-button" bedroomButtonController
|
||||
, Controller True "bedroom-drawer" bedroomDrawerController
|
||||
, Controller True "bedroom-humidifier" humidifierController
|
||||
, Controller True "school-light-controller" schoolLightController
|
||||
, Controller True "kitchen-motion-controller" kitchenMotionController
|
||||
, Controller True "livingroom-presence" livingroomPresenceController
|
||||
, Controller True "hallway-motion-controller" hallwayLightsController
|
||||
, Controller True "children-button" childrenBedroomButtonController
|
||||
[ Controller "bedroom-presence" bedroomPresenceController,
|
||||
Controller "bedroom-button" bedroomButtonController,
|
||||
Controller "bedroom-drawer" bedroomDrawerController,
|
||||
Controller "bedroom-humidifier" humidifierController,
|
||||
Controller "school-light-controller" schoolLightController,
|
||||
Controller "kitchen-motion-controller" kitchenMotionController,
|
||||
Controller "livingroom-presence" livingroomPresenceController,
|
||||
Controller "hallway-motion-controller" hallwayLightsController,
|
||||
Controller "children-button" childrenBedroomButtonController,
|
||||
Controller "livingroom-plants" livingroomPlantLights,
|
||||
Controller "children-filter" childrenAirFilterController
|
||||
]
|
||||
|
||||
-- | Steps the machine for every inbound message; service calls go to the
|
||||
-- bus. A restart re-dups the inbound channel and starts from the machine's
|
||||
-- initial state; messages broadcast during the restart window are lost.
|
||||
runController :: MonadIO m => FilePath -> Bus -> Controller -> m Void
|
||||
runController rootDir bus (Controller _enabled name machine ) = liftIO $ do
|
||||
inbound <- atomically (dupTChan (busInbound bus))
|
||||
let ns = Namespace [name]
|
||||
let workerDefinition = runMealy machine (runKatipContextT (busLogEnv bus) () ns . channelHassEval bus)
|
||||
let path = rootDir </> T.unpack name
|
||||
worker <- load path workerDefinition >>= \case
|
||||
Decoded a -> pure a
|
||||
FailDecode err a -> a <$ putStrLn ("Failed to load (" <> T.unpack name <> "): " <> err)
|
||||
runController :: forall m. (HasCallStack, MonadCatch m, KatipContext m, MonadIO m) => FilePath -> Bus -> Controller -> m Void
|
||||
runController rootDir bus (Controller name machine) = checkpoint (Annotation name) $ katipAddNamespace ns $ do
|
||||
inbound <- liftIO $ atomically (dupTChan (busInbound bus))
|
||||
let workerDefinition = runMealy machine (channelHassEval @m bus)
|
||||
let path = rootDir </> T.unpack name <.> "dat"
|
||||
worker <-
|
||||
load path workerDefinition >>= \case
|
||||
Decoded a -> pure a
|
||||
FailDecode err a -> a <$ logLocM WarningS (ls ("Failed to load (" <> T.unpack name <> "): " <> err))
|
||||
go path inbound worker
|
||||
where
|
||||
ns = Namespace [name]
|
||||
go path inbound f = do
|
||||
msg <- atomically (readTChan inbound)
|
||||
uuid <- UUID.V4.nextRandom
|
||||
(_, next) <- step path uuid f msg
|
||||
msg <- liftIO $ atomically (readTChan inbound)
|
||||
uuid <- liftIO UUID.V4.nextRandom
|
||||
(_, next) <- step path name uuid f msg
|
||||
go path inbound next
|
||||
|
||||
lookupPort :: IO Int
|
||||
lookupPort :: (MonadFail m, MonadIO m) => m Int
|
||||
lookupPort = do
|
||||
m <- lookupEnv "HA_METRICS_PORT"
|
||||
m <- liftIO (lookupEnv "HA_METRICS_PORT")
|
||||
case m of
|
||||
Nothing -> pure 8124
|
||||
Just s -> case readMaybe s of
|
||||
Just s -> case readMaybe s of
|
||||
Just p | p >= 1 && p <= 65535 -> pure p
|
||||
_ -> fail ("HA_METRICS_PORT must be a port in 1..65535: " <> s)
|
||||
|
||||
defaultMain :: IO ()
|
||||
defaultMain = withSocketsDo $ do
|
||||
severity <- maybe InfoS (const DebugS) <$> lookupEnv "HA_DEBUG"
|
||||
store <- System.Metrics.newStore
|
||||
System.Metrics.registerGcMetrics store
|
||||
appMetrics <- HomeAssistant.Runtime.Metrics.registerAppMetrics store
|
||||
rateLimitMetrics <- registerRateLimitMetrics store
|
||||
withBus severity appMetrics $ \bus -> do
|
||||
token <- getEnv "HA_TOKEN"
|
||||
host <- getEnv "HA_HOST"
|
||||
rootPath <- fromMaybe "/tmp/" <$> lookupEnv "HA_LIB_DIR"
|
||||
rrdPath <- fromMaybe "hass-controller.rrd" <$> lookupEnv "HA_RRD_PATH"
|
||||
rrdtool <- fromMaybe "rrdtool" <$> lookupEnv "HA_RRDTOOL"
|
||||
metricsPort <- lookupPort
|
||||
writerLimiter <- slidingWindowLimiter rateLimitMetrics 10 20
|
||||
let active = [c | c@(Controller True _ _) <- controllers]
|
||||
ents = foldMap (\(Controller _ _ m) -> entities m) active
|
||||
workers =
|
||||
[ ("reader", readerAction host 8123 token ents bus)
|
||||
, ("writer", writerAction writerLimiter bus)
|
||||
, ("metrics", HomeAssistant.Runtime.Metrics.metricsAction store rrdPath rrdtool)
|
||||
, ("metrics-http", HomeAssistant.Runtime.Graphing.graphAction rrdPath rrdtool metricsPort)
|
||||
] ++ [ (name, runController rootPath bus c) | c@(Controller True name _) <- active ]
|
||||
runKatipContextT (busLogEnv bus) () mempty $
|
||||
mapConcurrently_ (uncurry supervised) workers
|
||||
defaultMain =
|
||||
withSocketsDo $
|
||||
getSeverity >>= \s -> withLogEnv s $ \le -> runKatipContextT le () mempty $ do
|
||||
logLocM InfoS "Hello world"
|
||||
store <- liftIO System.Metrics.newStore
|
||||
liftIO $ System.Metrics.registerGcMetrics store
|
||||
appMetrics <- liftIO $ HomeAssistant.Runtime.Metrics.registerAppMetrics store
|
||||
rateLimitMetrics <- registerRateLimitMetrics store
|
||||
rootPath <- fromMaybe "/tmp/" <$> liftIO (lookupEnv "HA_LIB_DIR")
|
||||
let allNames = map (\(Controller n _) -> n) controllers
|
||||
flags <- loadFlags rootPath allNames
|
||||
withBus le appMetrics flags $ \bus -> do
|
||||
token <- liftIO $ getEnv "HA_TOKEN"
|
||||
host <- liftIO $ getEnv "HA_HOST"
|
||||
let rrdPath = rootPath </> "hass-controller.rrd"
|
||||
rrdtool <- fromMaybe "rrdtool" <$> liftIO (lookupEnv "HA_RRDTOOL")
|
||||
metricsPort <- lookupPort
|
||||
writerLimiter <- slidingWindowLimiter rateLimitMetrics 10 20
|
||||
forM_ controllers $ \(Controller n m) ->
|
||||
logLocM InfoS $ ls $ n <> ": " <> fromMaybe "" (runDiagramC m renderF)
|
||||
let ents = foldMap (\(Controller _ m) -> entities m) controllers
|
||||
workers =
|
||||
[ ("reader", readerAction host 8123 token ents bus),
|
||||
("writer", writerAction writerLimiter bus),
|
||||
("metrics", HomeAssistant.Runtime.Metrics.metricsAction store rrdPath rrdtool),
|
||||
("metrics-http", HttpServer.runHttpServer (busLogEnv bus) rrdPath rrdtool (busFlags bus) metricsPort)
|
||||
]
|
||||
++ [(name, runController rootPath bus c) | c@(Controller name _) <- controllers]
|
||||
runKatipContextT (busLogEnv bus) () mempty $
|
||||
mapConcurrently_ (uncurry supervised) workers
|
||||
where
|
||||
getSeverity = maybe InfoS (const DebugS) <$> lookupEnv "HA_DEBUG"
|
||||
|
||||
dryRunHassEval :: Namespace -> Bus -> HASSEff a -> IO a
|
||||
dryRunHassEval ns bus = \case
|
||||
CallService req x -> runKatipT (busLogEnv bus) $ do
|
||||
callId <- liftIO $ generateCallId (busGen bus)
|
||||
logF (sl "traceId" (toText (requestTraceId req))) ns DebugS (ls $ show (callId, x))
|
||||
CallServices req xs -> runKatipT (busLogEnv bus) $ forM_ xs $ \x -> do
|
||||
callId <- liftIO $ generateCallId (busGen bus)
|
||||
logF (sl "traceId" (toText (requestTraceId req))) ns DebugS (ls $ show (callId, x))
|
||||
Debug x -> runKatipT (busLogEnv bus) $ do
|
||||
logF () ns DebugS (ls $ show x)
|
||||
Trace req x -> runKatipT (busLogEnv bus) $ do
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
{-# LANGUAGE LambdaCase #-}
|
||||
{-# LANGUAGE OverloadedStrings #-}
|
||||
{-# LANGUAGE ScopedTypeVariables #-}
|
||||
|
||||
module HomeAssistant.Runtime.Bus
|
||||
( Bus(..)
|
||||
@@ -9,6 +10,7 @@ module HomeAssistant.Runtime.Bus
|
||||
, recordInbound
|
||||
, recordOutbound
|
||||
, channelHassEval
|
||||
, withLogEnv
|
||||
) where
|
||||
|
||||
import Control.Concurrent.STM
|
||||
@@ -32,6 +34,10 @@ import System.Metrics.Counter (inc)
|
||||
import Data.UUID (toText)
|
||||
import AFRP (Request(..), Event(..))
|
||||
import Control.Monad.IO.Class (MonadIO, liftIO)
|
||||
import HomeAssistant.Runtime.Flags (Flags)
|
||||
import Katip.Scribes.Journal (mkJournalScribe)
|
||||
import System.Environment (lookupEnv)
|
||||
import Data.Maybe (isJust)
|
||||
|
||||
-- | Shared runtime state: inbound is a broadcast channel (controllers
|
||||
-- read from 'dupTChan' copies), outbound queues service calls for the
|
||||
@@ -43,22 +49,38 @@ data Bus = Bus
|
||||
, busGen :: CallIdGen
|
||||
, busLogEnv :: LogEnv
|
||||
, busMetrics :: AppMetrics
|
||||
, busFlags :: Flags
|
||||
}
|
||||
|
||||
withBus :: Severity -> AppMetrics -> (Bus -> IO a) -> IO a
|
||||
withBus severity metrics callback = do
|
||||
handleScribe <- mkHandleScribe ColorIfTerminal stdout (permitItem severity) V2
|
||||
let makeLogEnv = registerScribe "stdout" handleScribe defaultScribeSettings =<< initLogEnv "hass-controller" "production"
|
||||
withLogEnv :: Severity -> (LogEnv -> IO a) -> IO a
|
||||
withLogEnv severity f = do
|
||||
let makeLogEnv = registerJournalScribe =<< registerHandleScribe =<< initLogEnv "hass-controller" "production"
|
||||
-- closeScribes will stop accepting new logs, flush existing ones and clean up resources
|
||||
bracket makeLogEnv closeScribes $ \le -> do
|
||||
bus <- Bus
|
||||
<$> newBroadcastTChanIO
|
||||
<*> newTChanIO
|
||||
<*> newTVarIO Nothing
|
||||
<*> mkCallIdGen 0
|
||||
<*> pure le
|
||||
<*> pure metrics
|
||||
callback bus
|
||||
bracket makeLogEnv closeScribes $ \le -> f le
|
||||
where
|
||||
registerJournalScribe :: LogEnv -> IO LogEnv
|
||||
registerJournalScribe le = do
|
||||
journalScribe <- mkJournalScribe (permitItem severity) V2
|
||||
registerScribe "journalctl" journalScribe defaultScribeSettings le
|
||||
registerHandleScribe le = do
|
||||
systemdUnit <- isJust <$> lookupEnv "HA_CONTROLLER_SYSTEMD"
|
||||
if systemdUnit
|
||||
then pure le -- ignore stdout when running in systemd
|
||||
else do
|
||||
handleScribe <- mkHandleScribe ColorIfTerminal stdout (permitItem severity) V2
|
||||
registerScribe "stdout" handleScribe defaultScribeSettings le
|
||||
|
||||
withBus :: MonadIO m => LogEnv -> AppMetrics -> Flags -> (Bus -> m a) -> m a
|
||||
withBus le metrics flags callback = do
|
||||
bus <- Bus
|
||||
<$> liftIO newBroadcastTChanIO
|
||||
<*> liftIO newTChanIO
|
||||
<*> liftIO (newTVarIO Nothing)
|
||||
<*> liftIO (mkCallIdGen 0)
|
||||
<*> pure le
|
||||
<*> pure metrics
|
||||
<*> pure flags
|
||||
callback bus
|
||||
|
||||
recordInbound :: Bus -> IO ()
|
||||
recordInbound bus = inc (amTriggersIn (busMetrics bus))
|
||||
@@ -66,14 +88,16 @@ recordInbound bus = inc (amTriggersIn (busMetrics bus))
|
||||
recordOutbound :: Bus -> IO ()
|
||||
recordOutbound bus = inc (amServicesOut (busMetrics bus))
|
||||
|
||||
channelHassEval :: (MonadIO m, KatipContext m) => Bus -> HASSEff a -> m a
|
||||
channelHassEval :: forall m a. (MonadIO m, KatipContext m) => Bus -> HASSEff a -> m a
|
||||
channelHassEval bus = \case
|
||||
CallService req svc -> katipAddContext (sl "traceId" (toText (requestTraceId req))) $ do
|
||||
logFM DebugS (ls $ show svc)
|
||||
liftIO $ atomically $ writeTChan (busOutbound bus) (req, svc)
|
||||
CallService req svc -> emit req svc
|
||||
CallServices req svcs -> mapM_ (emit req) svcs
|
||||
Debug x -> logFM DebugS (ls $ show x)
|
||||
Trace req x -> katipAddContext (sl "traceId" (toText (requestTraceId req))) $
|
||||
logFM InfoS (ls $ show x)
|
||||
where
|
||||
emit :: Request -> Service -> m ()
|
||||
emit req svc = liftIO $ atomically $ writeTChan (busOutbound bus) (req, svc)
|
||||
|
||||
newtype CallIdGen = CallIdGen { generateCallId :: IO Int }
|
||||
|
||||
|
||||
@@ -4,6 +4,7 @@
|
||||
module HomeAssistant.Runtime.Connection
|
||||
( readerAction
|
||||
, writerAction
|
||||
, dispatchService
|
||||
, encodeService
|
||||
, isTriggerEvent
|
||||
) where
|
||||
@@ -16,9 +17,7 @@ import Control.Concurrent.STM
|
||||
, writeTChan
|
||||
, writeTVar
|
||||
)
|
||||
import Control.Concurrent.Async (race)
|
||||
import Control.Concurrent (threadDelay)
|
||||
import Control.Exception (onException)
|
||||
import Control.Exception.Annotated (throw)
|
||||
import Control.Lens ((^?))
|
||||
import Control.Monad (forever, forM_, when)
|
||||
@@ -29,27 +28,30 @@ import qualified Data.Text as T
|
||||
import Data.Void (Void)
|
||||
import HomeAssistant.Controller (Service (..), Target (..))
|
||||
import HomeAssistant.Runtime.Bus
|
||||
import HomeAssistant.Runtime.Flags (isEnabled)
|
||||
import HomeAssistant.Runtime.Supervisor (Fatal (..))
|
||||
import qualified Network.WebSockets as WS
|
||||
import Katip (sl, logFM, Severity (..), ls, KatipContext, katipAddNamespace, katipAddContext)
|
||||
import Katip (sl, logFM, Severity (..), ls, Namespace (Namespace), KatipContext, katipAddNamespace, katipAddContext, logLocM)
|
||||
import Data.UUID (toText)
|
||||
import AFRP (Request(..), Event(..))
|
||||
import Control.Monad.IO.Class (liftIO, MonadIO)
|
||||
import HomeAssistant.Runtime.RateLimit (RateLimited, RateLimiter, runRateLimited)
|
||||
import Control.Monad.Catch (MonadCatch)
|
||||
import GHC.Stack (HasCallStack)
|
||||
import UnliftIO (MonadUnliftIO, race, withRunInIO)
|
||||
import Control.Monad.Catch (MonadCatch, onException)
|
||||
|
||||
-- | Connect, authenticate, subscribe, then receive and broadcast forever.
|
||||
-- Restarting this action reconnects. All setup sends happen before the
|
||||
-- connection is published in the bus, so only the writer sends afterwards.
|
||||
readerAction :: MonadIO m => String -> Int -> String -> S.Set T.Text -> Bus -> m Void
|
||||
readerAction host port token ents bus = liftIO $
|
||||
WS.runClient host port "/api/websocket" $ \conn -> do
|
||||
handshake conn token
|
||||
readerAction :: (MonadCatch m, HasCallStack, KatipContext m, MonadUnliftIO m, MonadIO m) => String -> Int -> String -> S.Set T.Text -> Bus -> m Void
|
||||
readerAction host port token ents bus = katipAddNamespace "receiver" $ withRunInIO $ \rio ->
|
||||
WS.runClient host port "/api/websocket" $ \conn -> rio $ do
|
||||
liftIO $ handshake conn token
|
||||
subscribe bus conn ents
|
||||
atomically $ writeTVar (busConn bus) (Just conn)
|
||||
putStrLn "[reader] connected"
|
||||
liftIO $ atomically $ writeTVar (busConn bus) (Just conn)
|
||||
logLocM InfoS "connected"
|
||||
-- Unpublish on exit so the writer blocks and the backlog survives the outage.
|
||||
receiveLoop bus conn `onException` atomically (writeTVar (busConn bus) Nothing)
|
||||
receiveLoop bus conn `onException` liftIO (atomically (writeTVar (busConn bus) Nothing))
|
||||
|
||||
handshake :: WS.Connection -> String -> IO ()
|
||||
handshake conn token = do
|
||||
@@ -71,12 +73,12 @@ expectType expected msg =
|
||||
isTriggerEvent :: Value -> Bool
|
||||
isTriggerEvent v = v ^? key "type" . _String == Just "event"
|
||||
|
||||
subscribe :: Bus -> WS.Connection -> S.Set T.Text -> IO ()
|
||||
subscribe :: HasCallStack => KatipContext m => Bus -> WS.Connection -> S.Set T.Text -> m ()
|
||||
subscribe bus conn ents =
|
||||
forM_ (S.toList ents) $ \entityId -> do
|
||||
print entityId
|
||||
sid <- generateCallId (busGen bus)
|
||||
WS.sendTextData conn $ encode $ object
|
||||
logLocM InfoS $ ls entityId
|
||||
sid <- liftIO $ generateCallId (busGen bus)
|
||||
liftIO $ WS.sendTextData conn $ encode $ object
|
||||
[ "id" .= sid
|
||||
, "type" .= ("subscribe_trigger" :: T.Text)
|
||||
, "trigger" .= object
|
||||
@@ -91,14 +93,14 @@ subscribe bus conn ents =
|
||||
-- Each read races a one-second timeout: a timeout broadcasts 'Tick' so
|
||||
-- time-based primitives (debounce, rollup, fixed, ...) keep advancing
|
||||
-- even when no state changes arrive.
|
||||
receiveLoop :: Bus -> WS.Connection -> IO Void
|
||||
receiveLoop :: (HasCallStack, MonadUnliftIO m, KatipContext m) => Bus -> WS.Connection -> m Void
|
||||
receiveLoop bus conn = forever $ do
|
||||
winner <- race (threadDelay 1_000_000) (WS.receiveData conn)
|
||||
winner <- race (liftIO $ threadDelay 1_000_000) (liftIO $ WS.receiveData conn)
|
||||
case winner of
|
||||
Left () -> atomically $ writeTChan (busInbound bus) Tick
|
||||
Left () -> liftIO $ atomically $ writeTChan (busInbound bus) Tick
|
||||
Right msg -> case eitherDecode msg of
|
||||
Left err -> putStrLn $ "[reader] skipping undecodable message: " <> err
|
||||
Right v -> do
|
||||
Left err -> logLocM WarningS $ ls $ "skipping undecodable message: " <> err
|
||||
Right v -> liftIO $ do
|
||||
when (isTriggerEvent v) (recordInbound bus)
|
||||
atomically $ writeTChan (busInbound bus) (Event v)
|
||||
|
||||
@@ -122,9 +124,20 @@ sendWithId bus conn svc = katipAddNamespace "connection" $ do
|
||||
writerAction :: (MonadIO m, KatipContext m, MonadCatch m) => RateLimiter -> Bus -> m Void
|
||||
writerAction rateLimiter bus = forever $ do
|
||||
(request, svc) <- liftIO $ atomically $ readTChan (busOutbound bus)
|
||||
katipAddContext (sl "traceId" (toText (requestTraceId request))) $ do
|
||||
katipAddContext (sl "traceId" (toText (requestTraceId request))) $
|
||||
katipAddNamespace (Namespace [requestHandler request]) $
|
||||
dispatchService rateLimiter bus request svc
|
||||
|
||||
-- | Sends the service call, or logs and drops it when its handler is disabled.
|
||||
dispatchService
|
||||
:: (MonadIO m, KatipContext m, MonadCatch m)
|
||||
=> RateLimiter -> Bus -> Request -> Service -> m ()
|
||||
dispatchService rateLimiter bus request svc = do
|
||||
enabled <- isEnabled (busFlags bus) (requestHandler request)
|
||||
let logPrefix = if enabled then "Calling: " else "Skipping: "
|
||||
logFM InfoS (ls $ logPrefix <> show svc)
|
||||
when enabled $ do
|
||||
conn <- liftIO $ atomically $ readTVar (busConn bus) >>= maybe retry pure
|
||||
-- runRateLimited rateLimiter $ sendWithId bus conn request svc
|
||||
runRateLimited rateLimiter $ sendWithId bus conn svc
|
||||
|
||||
encodeService :: Int -> Service -> Value
|
||||
@@ -133,17 +146,21 @@ encodeService callId Service{..} = object $
|
||||
, "type" .= ("call_service" :: T.Text)
|
||||
, "domain" .= serviceDomain
|
||||
, "service" .= serviceName
|
||||
, "target" .= targetObject serviceTarget
|
||||
, "target" .= targetObject serviceTarget serviceExclusions
|
||||
] <> maybe [] (\d -> ["service_data" .= d]) serviceData
|
||||
|
||||
|
||||
-- | A single target encodes as a scalar; multiple encode as a list. Empty
|
||||
-- lists are omitted so Home Assistant receives only populated keys.
|
||||
targetObject :: [Target] -> Value
|
||||
targetObject targets = object $ entityPart <> areaPart
|
||||
-- lists are omitted so Home Assistant receives only populated keys. Exclusions
|
||||
-- nest under "exclude".
|
||||
targetObject :: [Target] -> [Target] -> Value
|
||||
targetObject targets exclusions = object $
|
||||
targetKeys targets
|
||||
<> [ "exclude" .= object (targetKeys exclusions) | not (null exclusions) ]
|
||||
where
|
||||
entityPart = emit "entity_id" [e | EntityId e <- targets]
|
||||
areaPart = emit "area_id" [a | AreaId a <- targets]
|
||||
targetKeys ts = emit "entity_id" [e | EntityId e <- ts]
|
||||
<> emit "area_id" [a | AreaId a <- ts]
|
||||
<> emit "label_id" [l | LabelId l <- ts]
|
||||
emit _ [] = []
|
||||
emit k [x] = [k .= x]
|
||||
emit k many = [k .= many]
|
||||
@@ -0,0 +1,93 @@
|
||||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
module HomeAssistant.Runtime.Flags
|
||||
( Name
|
||||
, Flags(..)
|
||||
, loadFlags
|
||||
, isEnabled
|
||||
, setEnabled
|
||||
, allFlags
|
||||
, validNames
|
||||
) where
|
||||
|
||||
import Control.Concurrent.MVar (MVar, newMVar, withMVar)
|
||||
import Control.Concurrent.STM (TVar, atomically, newTVarIO, readTVarIO, stateTVar)
|
||||
import Control.Monad.IO.Class (MonadIO, liftIO)
|
||||
import qualified Conduit as C
|
||||
import Conduit ((.|))
|
||||
import Data.Aeson (decodeFileStrict', encode)
|
||||
import qualified Data.ByteString.Lazy as BL
|
||||
import Data.Map.Strict (Map)
|
||||
import qualified Data.Map.Strict as M
|
||||
import Data.Set (Set)
|
||||
import qualified Data.Set as S
|
||||
import Data.Text (Text)
|
||||
import System.FilePath ((</>))
|
||||
import System.IO.Error (isDoesNotExistError)
|
||||
import GHC.Stack (HasCallStack)
|
||||
import Katip (KatipContext, logLocM, Severity (..), ls)
|
||||
import Control.Monad.Catch (MonadCatch, handle)
|
||||
import Control.Exception (IOException)
|
||||
import Data.Maybe (fromMaybe)
|
||||
|
||||
type Name = Text
|
||||
|
||||
data Flags = Flags
|
||||
{ flagsState :: TVar (Map Name Bool)
|
||||
, flagsLock :: MVar ()
|
||||
, flagsPath :: FilePath
|
||||
, flagsValidNames :: Set Text
|
||||
}
|
||||
|
||||
loadFlags :: (KatipContext m, MonadCatch m, MonadIO m) => FilePath -> [Name] -> m Flags
|
||||
loadFlags rootPath allNames = do
|
||||
let path = rootPath </> "handlers.json"
|
||||
fileMap <- readFlagsFile path
|
||||
let defaults = M.fromList [(n, True) | n <- allNames]
|
||||
initial = M.unionWith const fileMap defaults
|
||||
tv <- liftIO $ newTVarIO initial
|
||||
lock <- liftIO $ newMVar ()
|
||||
pure Flags
|
||||
{ flagsState = tv
|
||||
, flagsLock = lock
|
||||
, flagsPath = path
|
||||
, flagsValidNames = S.fromList allNames
|
||||
}
|
||||
|
||||
readFlagsFile :: forall m. (HasCallStack, KatipContext m, MonadCatch m) => FilePath -> m (Map Name Bool)
|
||||
readFlagsFile path =
|
||||
handle onMissingOrUnreadable $ do
|
||||
decoded <- liftIO $ decodeFileStrict' path
|
||||
case decoded of
|
||||
Nothing -> do
|
||||
logLocM WarningS $ ls ("handlers.json is unparseable; treating all handlers as enabled: " <> path)
|
||||
pure mempty
|
||||
Just m -> pure (fromMaybe mempty m)
|
||||
where
|
||||
onMissingOrUnreadable :: HasCallStack => IOException -> m (Map Name Bool)
|
||||
onMissingOrUnreadable e
|
||||
| isDoesNotExistError e = pure mempty
|
||||
| otherwise = do
|
||||
logLocM WarningS $ ls ("could not read handlers.json (" <> show e <> "); treating all handlers as enabled")
|
||||
pure mempty
|
||||
|
||||
isEnabled :: MonadIO m => Flags -> Name -> m Bool
|
||||
isEnabled flags name = liftIO $
|
||||
M.findWithDefault True name <$> readTVarIO (flagsState flags)
|
||||
|
||||
allFlags :: MonadIO m => Flags -> m (Map Name Bool)
|
||||
allFlags flags = liftIO $ readTVarIO (flagsState flags)
|
||||
|
||||
setEnabled :: MonadIO m => Flags -> Name -> Bool -> m ()
|
||||
setEnabled Flags{flagsState, flagsLock, flagsPath} name val =
|
||||
liftIO $ withMVar flagsLock $ \_ -> do
|
||||
m <- atomically $ stateTVar flagsState $ \cur ->
|
||||
let next = M.insert name val cur in (next, next)
|
||||
safeWrite flagsPath m
|
||||
|
||||
validNames :: Flags -> Set Text
|
||||
validNames = flagsValidNames
|
||||
|
||||
safeWrite :: FilePath -> Map Name Bool -> IO ()
|
||||
safeWrite path m = C.runResourceT $ C.runConduit $
|
||||
C.yieldMany [BL.toStrict (encode m)] .| C.sinkFileCautious path
|
||||
@@ -11,37 +11,20 @@ module HomeAssistant.Runtime.Graphing
|
||||
, parseNameParam
|
||||
, buildGraphArgs
|
||||
, readProcessBytes
|
||||
, graphAction
|
||||
, Graph(..)
|
||||
, renderGraph
|
||||
, rangeSuffix
|
||||
) where
|
||||
|
||||
import Control.Exception (evaluate)
|
||||
import Control.Monad (forever)
|
||||
import Control.Monad.IO.Class (liftIO, MonadIO)
|
||||
import qualified Data.ByteString as BS
|
||||
import qualified Data.ByteString.Lazy as BL
|
||||
import Data.Text (Text)
|
||||
import qualified Data.Text as T
|
||||
import qualified Data.Text.Lazy as TL
|
||||
import Data.Void (Void)
|
||||
import Network.HTTP.Types.Status (Status, status400, status404, status500)
|
||||
import Network.Wai.Handler.Warp (defaultSettings, setHost, setPort)
|
||||
import System.Exit (ExitCode (..))
|
||||
import System.IO (hGetContents)
|
||||
import System.Process (CreateProcess (..), StdStream (..), proc, waitForProcess, withCreateProcess)
|
||||
import Web.Scotty
|
||||
( ActionM
|
||||
, ScottyM
|
||||
, defaultOptions
|
||||
, get
|
||||
, pathParam
|
||||
, queryParamMaybe
|
||||
, raw
|
||||
, scottyOpts
|
||||
, setHeader
|
||||
, settings
|
||||
, status
|
||||
, text
|
||||
)
|
||||
import Servant.API (FromHttpApiData (..), ToHttpApiData (..))
|
||||
|
||||
data Range = TenMinutes | OneHour | OneDay | OneWeek | OneMonth
|
||||
deriving (Eq, Show, Bounded, Enum)
|
||||
@@ -56,6 +39,12 @@ rangeSuffix OneMonth = "30d"
|
||||
parseRange :: Text -> Maybe Range
|
||||
parseRange t = lookup t [(T.pack (rangeSuffix r), r) | r <- [minBound .. maxBound]]
|
||||
|
||||
instance ToHttpApiData Range where
|
||||
toQueryParam = T.pack . rangeSuffix
|
||||
|
||||
instance FromHttpApiData Range where
|
||||
parseQueryParam x = maybe (Left ("Could not parse '" <> x <> "' as Range")) Right $ parseRange x
|
||||
|
||||
rangeStart :: Range -> String
|
||||
rangeStart r = "end-" ++ rangeSuffix r
|
||||
|
||||
@@ -91,6 +80,7 @@ data GraphSpec = GraphSpec
|
||||
{ gsName :: Text
|
||||
, gsTitle :: String
|
||||
, gsPlots :: [Plot]
|
||||
, gsIdentifier :: Graph
|
||||
}
|
||||
deriving (Eq, Show)
|
||||
|
||||
@@ -141,6 +131,7 @@ ratelimitGraph =
|
||||
, serLabel = "Requests exhausted/min"
|
||||
}
|
||||
]
|
||||
, gsIdentifier = RateLimit
|
||||
}
|
||||
|
||||
trafficGraph :: GraphSpec
|
||||
@@ -164,6 +155,7 @@ trafficGraph =
|
||||
, serLabel = "Service calls out/min"
|
||||
}
|
||||
]
|
||||
, gsIdentifier = Traffic
|
||||
}
|
||||
|
||||
memoryGraph :: GraphSpec
|
||||
@@ -174,17 +166,21 @@ memoryGraph =
|
||||
[ area "live" "#99ccff" (average "rts_gc_current__a7a")
|
||||
, line "peak" "#cc0000" (maximumCF "rts_gc_current__a7a")
|
||||
]
|
||||
Memory
|
||||
|
||||
graphs :: [GraphSpec]
|
||||
graphs = [memoryGraph, ratelimitGraph, trafficGraph]
|
||||
|
||||
lookupGraph :: [GraphSpec] -> Text -> Maybe GraphSpec
|
||||
lookupGraph specs name = case [g | g <- specs, gsName g == name] of
|
||||
-- XXX: Proper lookup..?
|
||||
lookupGraph :: [GraphSpec] -> Graph -> Maybe GraphSpec
|
||||
lookupGraph specs graphMode = case [g | g <- specs, gsIdentifier g == graphMode] of
|
||||
(g : _) -> Just g
|
||||
[] -> Nothing
|
||||
|
||||
parseNameParam :: [GraphSpec] -> Text -> Maybe GraphSpec
|
||||
parseNameParam specs t = T.stripSuffix ".png" t >>= lookupGraph specs
|
||||
parseNameParam specs t = rightToMaybe (parseQueryParam t) >>= lookupGraph specs
|
||||
where
|
||||
rightToMaybe = either (const Nothing) Just
|
||||
|
||||
cfName :: CF -> String
|
||||
cfName = \case
|
||||
@@ -195,10 +191,10 @@ cfName = \case
|
||||
|
||||
defArgs :: FilePath -> Series -> [String]
|
||||
defArgs rrdPath series =
|
||||
[ "DEF:" ++ rawF ++ "=" ++ rrdPath ++ ":"
|
||||
( "DEF:" ++ rawF ++ "=" ++ rrdPath ++ ":"
|
||||
++ srcDs source ++ ":" ++ cfName (srcCF source)
|
||||
]
|
||||
++ transformArgs
|
||||
)
|
||||
: transformArgs
|
||||
where
|
||||
source = serSource series
|
||||
alias = serAlias series
|
||||
@@ -255,39 +251,32 @@ readProcessBytes cmd args =
|
||||
pure (code, out, err)
|
||||
_ -> pure (ExitFailure 1, BS.empty, "failed to create pipes")
|
||||
|
||||
respond :: Status -> TL.Text -> ActionM ()
|
||||
respond st body = status st >> text body
|
||||
|
||||
serve :: FilePath -> FilePath -> GraphSpec -> Range -> ActionM ()
|
||||
serve rrdPath rrdtool spec range = do
|
||||
renderGraph :: MonadIO m => FilePath -> FilePath -> GraphSpec -> Range -> m (Either Text BS.ByteString)
|
||||
renderGraph rrdPath rrdtool spec range = do
|
||||
(code, out, err) <- liftIO (readProcessBytes rrdtool (buildGraphArgs rrdPath spec range))
|
||||
case code of
|
||||
ExitSuccess
|
||||
| not (BS.null out) -> do
|
||||
setHeader "Content-Type" "image/png"
|
||||
raw (BL.fromStrict out)
|
||||
| otherwise -> respond status500 "empty graph"
|
||||
_ -> respond status500 (TL.pack (take 200 err))
|
||||
| not (BS.null out) -> pure $ Right out
|
||||
| otherwise -> pure $ Left "empty graph"
|
||||
_ -> pure $ Left (T.pack $ take 200 err)
|
||||
|
||||
handler :: FilePath -> FilePath -> ActionM ()
|
||||
handler rrdPath rrdtool = do
|
||||
name <- pathParam "name"
|
||||
case parseNameParam graphs name of
|
||||
Nothing -> respond status404 "unknown graph"
|
||||
Just spec -> do
|
||||
rangeArg <- queryParamMaybe "range"
|
||||
case rangeArg of
|
||||
Nothing -> serve rrdPath rrdtool spec OneDay
|
||||
Just t -> case parseRange t of
|
||||
Nothing -> respond status400 "invalid range"
|
||||
Just range -> serve rrdPath rrdtool spec range
|
||||
|
||||
app :: FilePath -> FilePath -> ScottyM ()
|
||||
app rrdPath rrdtool = get "/metrics/:name" (handler rrdPath rrdtool)
|
||||
|
||||
graphAction :: MonadIO m => FilePath -> FilePath -> Int -> m Void
|
||||
graphAction rrdPath rrdtool port = liftIO $ forever $ scottyOpts opts (app rrdPath rrdtool)
|
||||
where
|
||||
opts = defaultOptions
|
||||
{ settings = setHost "0.0.0.0" (setPort port defaultSettings)
|
||||
}
|
||||
|
||||
data Graph
|
||||
= Memory
|
||||
| Traffic
|
||||
| RateLimit
|
||||
deriving (Show, Eq, Enum, Bounded)
|
||||
|
||||
instance ToHttpApiData Graph where
|
||||
toQueryParam Memory = "memory.png"
|
||||
toQueryParam Traffic = "traffic.png"
|
||||
toQueryParam RateLimit = "ratelimit.png"
|
||||
|
||||
instance FromHttpApiData Graph where
|
||||
parseQueryParam "memory.png" = Right Memory
|
||||
parseQueryParam "traffic.png" = Right Traffic
|
||||
parseQueryParam "ratelimit.png" = Right RateLimit
|
||||
parseQueryParam x = Left ("Can't parse '" <> x <> "' as Graph")
|
||||
|
||||
@@ -38,12 +38,13 @@ data RateLimiter = RateLimiter
|
||||
|
||||
|
||||
slidingWindowLimiter
|
||||
:: RateLimitMetrics
|
||||
:: MonadIO m
|
||||
=> RateLimitMetrics
|
||||
-> NominalDiffTime -- ^ Within how many seconds
|
||||
-> Int -- ^ How many requests we can make
|
||||
-> IO RateLimiter
|
||||
-> m RateLimiter
|
||||
slidingWindowLimiter metrics timeWindow size = do
|
||||
window <- newTVarIO []
|
||||
window <- liftIO $ newTVarIO []
|
||||
return $ RateLimiter metrics $ \(RateLimited action) -> do
|
||||
now <- liftIO getPOSIXTime
|
||||
allowed <- liftIO $ atomically $ do
|
||||
|
||||
@@ -0,0 +1,242 @@
|
||||
{-# LANGUAGE OverloadedStrings #-}
|
||||
{-# LANGUAGE DerivingVia #-}
|
||||
module HttpServer where
|
||||
|
||||
import Control.Monad (forever)
|
||||
import Control.Monad.IO.Class (liftIO, MonadIO)
|
||||
import qualified Data.ByteString as BS
|
||||
import Data.Void (Void)
|
||||
import Network.Wai.Handler.Warp (run)
|
||||
import Servant.API ((:>), Capture, Get, QueryParam, (:-), MimeRender (..), Accept (..), NamedRoutes, JSON, ReqBody, Put, Post, FormUrlEncoded, Header)
|
||||
import Data.ByteString (ByteString)
|
||||
import GHC.Generics (Generic)
|
||||
import Servant (Handler, err404, fieldLink, toUrlPiece)
|
||||
import Control.Monad.Catch (throwM, catch, MonadCatch, MonadThrow, SomeException)
|
||||
import Servant.Server (err500, ServerT)
|
||||
import Data.Maybe (fromMaybe)
|
||||
import Data.Map.Strict (Map)
|
||||
import qualified Data.Set as S
|
||||
import Data.Text (Text)
|
||||
import HomeAssistant.Runtime.Flags (Flags, allFlags, setEnabled, validNames, isEnabled)
|
||||
import Control.Exception.Annotated (checkpoint, Annotation (Annotation))
|
||||
import Servant.Server.Generic (genericServeT)
|
||||
import Network.Wai (Application)
|
||||
import Network.HTTP.Media ((//))
|
||||
import HomeAssistant.Runtime.Graphing (Graph (..), Range (..), lookupGraph, graphs, renderGraph, rangeSuffix)
|
||||
import Katip (KatipContextT, Katip, runKatipContextT, LogEnv, KatipContext, ls, Severity (..), logFM, katipAddContext, sl)
|
||||
import Data.Aeson (ToJSON (toJSON), FromJSON, object, (.=))
|
||||
import Lucid (ToHtml, toHtml, renderBS, toHtmlRaw, HtmlT, Attributes)
|
||||
import qualified Lucid.Html5 as H5
|
||||
import qualified Data.Map.Strict as M
|
||||
import Data.Foldable (for_)
|
||||
import qualified Data.Text as T
|
||||
import Web.FormUrlEncoded (FromForm, fromForm, parseUnique)
|
||||
import Lucid.Base (makeAttributes)
|
||||
import Data.Aeson.Key (fromText)
|
||||
|
||||
data ImagePng
|
||||
|
||||
instance MimeRender ImagePng GraphPng where
|
||||
mimeRender _ (GraphPng bs) = BS.fromStrict bs
|
||||
|
||||
instance Accept ImagePng where
|
||||
contentType _ = "image" // "png"
|
||||
|
||||
-- `servant-lucid` package would provide this and the instance for the original lucid(1) package
|
||||
-- but we have lucid2
|
||||
data HTML
|
||||
|
||||
instance Accept HTML where
|
||||
contentType _ = "text" // "html"
|
||||
|
||||
instance ToHtml a => MimeRender HTML a where
|
||||
mimeRender _ = renderBS . toHtml
|
||||
|
||||
newtype StatsPage = StatsPage (forall m. Monad m => HtmlT m ())
|
||||
|
||||
instance ToHtml StatsPage where
|
||||
toHtml (StatsPage inner) = inner
|
||||
toHtmlRaw = toHtml
|
||||
|
||||
page_ :: Monad m => HtmlT m () -> HtmlT m ()
|
||||
page_ inner = H5.doctypehtml_ $ do
|
||||
H5.head_ $ do
|
||||
H5.script_
|
||||
[ H5.src_ "https://cdn.jsdelivr.net/npm/htmx.org@2.0.11/dist/htmx.min.js"
|
||||
, H5.integrity_ "sha384-2OatzQy1H+Zd/IIrjr1TcuDGqLXeHhbooAyJY1KdQMKnr4LZ22k31GBLdYKHmVjg"
|
||||
, H5.crossorigin_ "anonymous"
|
||||
]
|
||||
("" :: Text)
|
||||
H5.style_ css
|
||||
H5.body_ inner
|
||||
|
||||
css :: Text
|
||||
css = T.unlines
|
||||
[ "body { font-family: system-ui, sans-serif; margin: 1rem auto; max-width: 40rem; padding: 0 1rem; }"
|
||||
, "table { border-collapse: collapse; }"
|
||||
, "th, td { padding: 0.4rem 0.75rem; border-bottom: 1px solid #ddd; text-align: left; }"
|
||||
, "input[type=submit] { padding: 0.25rem 0.75rem; cursor: pointer; }"
|
||||
, "img { max-width: 100%; }"
|
||||
]
|
||||
|
||||
|
||||
type HxRequest = Header "HX-Request" Bool
|
||||
|
||||
data API mode = API
|
||||
{ getMetrics :: mode :- "metrics" :> Capture "graph" Graph :> QueryParam "range" Range :> Get '[ImagePng] GraphPng
|
||||
, getStats :: mode :- "stats" :> HxRequest :> QueryParam "range" Range :> Get '[HTML] StatsPage
|
||||
, getFlags :: mode :- "flags" :> Get '[JSON, HTML] FlagsResponse
|
||||
, putFlag :: mode :- "flags" :> Capture "name" Text :> ReqBody '[JSON, FormUrlEncoded] FlagValue :> Put '[HTML, JSON] FlagResponse
|
||||
, postFlag :: mode :- "flags" :> Capture "name" Text :> ReqBody '[JSON, FormUrlEncoded] FlagValue :> Post '[JSON, HTML] FlagResponse
|
||||
}
|
||||
deriving Generic
|
||||
|
||||
newtype GraphPng = GraphPng ByteString
|
||||
|
||||
newtype FlagValue = FlagValue Bool
|
||||
deriving FromJSON via Bool
|
||||
|
||||
instance FromForm FlagValue where
|
||||
fromForm f = FlagValue <$> parseUnique "flag-value" f
|
||||
|
||||
newtype FlagsResponse = FlagsResponse (Map Text Bool)
|
||||
deriving (ToJSON) via (Map Text Bool)
|
||||
|
||||
data FlagResponse = FlagResponse Text Bool
|
||||
|
||||
instance ToHtml FlagResponse where
|
||||
toHtml (FlagResponse name value) = flagRow name value
|
||||
toHtmlRaw = toHtml
|
||||
|
||||
instance ToJSON FlagResponse where
|
||||
toJSON (FlagResponse k v) = object [fromText k .= v]
|
||||
|
||||
flagsPage :: Monad m => FlagsResponse -> HtmlT m ()
|
||||
flagsPage (FlagsResponse f) = page_ $
|
||||
H5.table_ $ do
|
||||
H5.tr_ $ do
|
||||
H5.th_ "Name"
|
||||
H5.th_ "Value"
|
||||
H5.th_ ""
|
||||
for_ (M.toList f) $ uncurry flagRow
|
||||
|
||||
flagRow :: Monad m => Text -> Bool -> HtmlT m ()
|
||||
flagRow name value = H5.tr_ [H5.id_ (rowId name)] $ do
|
||||
H5.td_ (toHtml name)
|
||||
H5.td_ (toHtml (if value then "on" else "off" :: Text))
|
||||
H5.td_ (toggle name value)
|
||||
where
|
||||
toggle :: Monad m => Text -> Bool -> HtmlT m ()
|
||||
toggle key current = H5.form_ [H5.method_ "post", H5.action_ (postFlagsLink key)] $ do
|
||||
H5.input_ [H5.name_ "flag-value", H5.type_ "hidden", H5.value_ (T.pack (show (not current)))]
|
||||
H5.input_
|
||||
[ H5.type_ "submit"
|
||||
, H5.value_ (if current then "Disable" else "Enable")
|
||||
, hxTrigger "click"
|
||||
, hxTarget ("#" <> rowId key)
|
||||
, hxPut (postFlagsLink key)
|
||||
, hxSwap "outerHTML"
|
||||
]
|
||||
postFlagsLink k = "/" <> toUrlPiece (fieldLink putFlag k)
|
||||
|
||||
rowId :: Text -> Text
|
||||
rowId = ("status-" <>)
|
||||
|
||||
hxTrigger :: Text -> Attributes
|
||||
hxTrigger = makeAttributes "hx-trigger"
|
||||
|
||||
hxTarget :: Text -> Attributes
|
||||
hxTarget = makeAttributes "hx-target"
|
||||
|
||||
hxPut :: Text -> Attributes
|
||||
hxPut = makeAttributes "hx-put"
|
||||
|
||||
hxGet :: Text -> Attributes
|
||||
hxGet = makeAttributes "hx-get"
|
||||
|
||||
hxPushUrl :: Text -> Attributes
|
||||
hxPushUrl = makeAttributes "hx-push-url"
|
||||
|
||||
hxSwap :: Text -> Attributes
|
||||
hxSwap = makeAttributes "hx-swap"
|
||||
|
||||
instance ToHtml FlagsResponse where
|
||||
toHtml = flagsPage
|
||||
toHtmlRaw = toHtml
|
||||
|
||||
getFlagsHandler :: Flags -> LoggingHandler FlagsResponse
|
||||
getFlagsHandler = fmap FlagsResponse . allFlags
|
||||
|
||||
putFlagHandler :: Flags -> Text -> FlagValue -> LoggingHandler FlagResponse
|
||||
putFlagHandler flags name (FlagValue val)
|
||||
| name `S.notMember` validNames flags = throwM err404
|
||||
| otherwise = checkpoint (Annotation (name, val)) $ katipAddContext (sl "flag" (name, val)) $ do
|
||||
setEnabled flags name val `catch` \e -> do
|
||||
logFM ErrorS (ls ("failed to persist handler flag: " <> show (e :: SomeException)))
|
||||
throwM err500
|
||||
FlagResponse name <$> isEnabled flags name
|
||||
|
||||
|
||||
getMetricsHandler :: FilePath -> FilePath -> Graph -> Maybe Range -> LoggingHandler GraphPng
|
||||
getMetricsHandler rrdPath rrdtool graphMode mRange = checkpoint (Annotation (graphMode, mRange)) $ do
|
||||
case lookupGraph graphs graphMode of
|
||||
Nothing -> throwM err404
|
||||
Just spec -> do
|
||||
let range = fromMaybe OneDay mRange
|
||||
g <- renderGraph rrdPath rrdtool spec range
|
||||
either (\e -> logFM ErrorS (ls e) >> throwM err500) (pure . GraphPng) g
|
||||
|
||||
-- server :: FilePath -> FilePath -> API AsServer
|
||||
server :: FilePath -> FilePath -> Flags -> ServerT (NamedRoutes API) LoggingHandler
|
||||
server rrdPath rrdtool flags = API
|
||||
{ getMetrics = getMetricsHandler rrdPath rrdtool
|
||||
, getStats = getStatsHandler
|
||||
, getFlags = getFlagsHandler flags
|
||||
, putFlag = putFlagHandler flags
|
||||
, postFlag = putFlagHandler flags -- This exists only for html forms
|
||||
}
|
||||
|
||||
statsPage :: Maybe Bool -> Maybe Range -> StatsPage
|
||||
statsPage hx r = StatsPage $
|
||||
if hx == Just True
|
||||
then statsContent r
|
||||
else page_ (statsContent r)
|
||||
|
||||
statsContent :: Monad m => Maybe Range -> HtmlT m ()
|
||||
statsContent r = H5.div_ [H5.id_ "stats"] $ do
|
||||
H5.ul_ $ for_ [minBound..maxBound] $ \range ->
|
||||
H5.li_ $ H5.a_ (link range) $ toHtml $ rangeSuffix range
|
||||
H5.h2_ "Traffic"
|
||||
H5.img_ [H5.src_ (src Traffic)]
|
||||
H5.h2_ "Memory"
|
||||
H5.img_ [H5.src_ (src Memory)]
|
||||
H5.h2_ "Ratelimit"
|
||||
H5.img_ [H5.src_ (src RateLimit)]
|
||||
where
|
||||
src m = "/" <> toUrlPiece (fieldLink getMetrics m r)
|
||||
link range =
|
||||
let url = "/" <> toUrlPiece (fieldLink getStats (Just range))
|
||||
in [ H5.href_ url
|
||||
, hxGet url
|
||||
, hxTarget "#stats"
|
||||
, hxSwap "outerHTML"
|
||||
, hxPushUrl "true"
|
||||
]
|
||||
|
||||
getStatsHandler :: Maybe Bool -> Maybe Range -> LoggingHandler StatsPage
|
||||
getStatsHandler hx r = pure (statsPage hx r)
|
||||
|
||||
servantApp :: LogEnv -> FilePath -> FilePath -> Flags -> Application
|
||||
servantApp le rrdPath rrdtool flags = genericServeT (toHandler le) (server rrdPath rrdtool flags)
|
||||
|
||||
runHttpServer :: MonadIO m => LogEnv -> FilePath -> FilePath -> Flags -> Int -> m Void
|
||||
runHttpServer le rrdPath rrdtool flags port = liftIO $ forever $ run port (servantApp le rrdPath rrdtool flags)
|
||||
|
||||
newtype LoggingHandler a = LoggingHandler (KatipContextT Handler a)
|
||||
deriving (Functor, Applicative, Monad, MonadIO, Katip, KatipContext, MonadCatch, MonadThrow) via (KatipContextT Handler)
|
||||
|
||||
toHandler :: LogEnv -> (forall a. LoggingHandler a -> Handler a)
|
||||
toHandler le (LoggingHandler k) = runKatipContextT le () "http" k
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,70 @@
|
||||
{-# LANGUAGE OverloadedStrings #-}
|
||||
module Katip.Scribes.Journal where
|
||||
|
||||
import Data.Text.Lazy qualified as TL
|
||||
import Data.Text.Lazy.Builder qualified as Builder
|
||||
import Katip (Item (..), LogStr (..), PermitFunc, Scribe (..), Verbosity (..), permitItem, Severity (..), registerScribe, defaultScribeSettings, initLogEnv, closeScribes, runKatipContextT, logLocM, LogItem, Namespace (..), getThreadIdText, payloadObject, katipAddContext, sl, getEnvironment)
|
||||
import Systemd.Journal qualified as J
|
||||
import Control.Exception (bracket)
|
||||
import GHC.Stack (HasCallStack)
|
||||
import qualified Data.Text as T
|
||||
import qualified Data.HashMap.Strict as HashMap
|
||||
import qualified Data.Text.Encoding as TE
|
||||
import qualified Data.Aeson as A
|
||||
import qualified Data.ByteString.Lazy as BL
|
||||
import qualified Data.Aeson.KeyMap as KeyMap
|
||||
import qualified Data.Aeson.Key as Key
|
||||
import qualified Data.ByteString as B
|
||||
|
||||
mkJournalScribe :: PermitFunc -> Verbosity -> IO Scribe
|
||||
mkJournalScribe permitFunc verbosity =
|
||||
pure $
|
||||
Scribe
|
||||
{ liPush = \i ->
|
||||
J.sendMessageWith (TL.toStrict $ Builder.toLazyText $ unLogStr $ _itemMessage i) (itemToJournalFields verbosity i),
|
||||
scribeFinalizer = pure (), -- no cleanup?
|
||||
scribePermitItem = permitFunc
|
||||
}
|
||||
|
||||
itemToJournalFields :: forall a. LogItem a => Verbosity -> Item a -> J.JournalFields
|
||||
itemToJournalFields verbosity item = mconcat
|
||||
[ J.syslogIdentifier (unNS item)
|
||||
, J.priority (mapPriority item)
|
||||
, thread item
|
||||
, payload item
|
||||
, environment item
|
||||
]
|
||||
where
|
||||
mapPriority i =
|
||||
case _itemSeverity i of
|
||||
DebugS -> J.Debug
|
||||
InfoS -> J.Info
|
||||
NoticeS -> J.Notice
|
||||
WarningS -> J.Warning
|
||||
ErrorS -> J.Error
|
||||
CriticalS -> J.Critical
|
||||
AlertS -> J.Alert
|
||||
EmergencyS -> J.Emergency
|
||||
unNS = T.intercalate "." . unNamespace . _itemNamespace
|
||||
thread i = HashMap.singleton (katipField "thread") (TE.encodeUtf8 $ getThreadIdText $ _itemThread i)
|
||||
environment i = HashMap.singleton (katipField "environment") (TE.encodeUtf8 $ getEnvironment $ _itemEnv i)
|
||||
payload :: Item a -> J.JournalFields
|
||||
payload i = -- HashMap.singleton (J.mkJournalField "payload") (BL.toStrict $ A.encode $ payloadObject verbosity $ _itemPayload i)
|
||||
HashMap.fromList $ map (\(k,v) -> (katipField (Key.toText k), encodeValue v)) $ KeyMap.toList $ payloadObject verbosity $ _itemPayload i
|
||||
-- The upstream doesn't handle '-'
|
||||
katipField = J.mkJournalField . T.replace "-" "_" . ("KATIP_" <>)
|
||||
encodeValue :: A.Value -> B.ByteString
|
||||
encodeValue = \case
|
||||
-- Handle simple scalar values as is
|
||||
A.String t -> TE.encodeUtf8 t
|
||||
x -> BL.toStrict $ A.encode x
|
||||
|
||||
test :: HasCallStack => IO ()
|
||||
test = do
|
||||
scribe <- mkJournalScribe (permitItem InfoS) V2
|
||||
let makeLogEnv = registerScribe "journald" scribe defaultScribeSettings =<< initLogEnv "hass-controller" "dev"
|
||||
bracket makeLogEnv closeScribes $ \le -> do
|
||||
runKatipContextT le () "findme-context" $
|
||||
katipAddContext (sl "trace-id" ("abcdefg" :: String)) $
|
||||
logLocM InfoS "Hello world"
|
||||
pure ()
|
||||
@@ -12,6 +12,10 @@ import Support (fakeRequest)
|
||||
import Test.Hspec (Spec, describe, it)
|
||||
import Test.Hspec.Hedgehog (forAll, forAllWith, hedgehog, (===))
|
||||
|
||||
-- We are testing laws -> hlint warns about not using laws
|
||||
{-# ANN module "Hlint: ignore" #-}
|
||||
|
||||
|
||||
-- | Law tests for the Mealy instances. Two machines count as equal when
|
||||
-- they emit equal outputs on every input sequence, so each law runs both
|
||||
-- sides on generated inputs.
|
||||
|
||||
+8
-6
@@ -19,9 +19,11 @@ import qualified Hedgehog.Gen as Gen
|
||||
import qualified Hedgehog.Range as Range
|
||||
import Test.Hspec
|
||||
import Test.Hspec.Hedgehog
|
||||
import Data.Maybe (listToMaybe)
|
||||
import AFRP.Diagram (emptyDiagram)
|
||||
|
||||
fakeRequest :: Request
|
||||
fakeRequest = Request (sec 0) utc nil
|
||||
fakeRequest = Request (sec 0) utc nil "test"
|
||||
|
||||
sec :: Integer -> UTCTime
|
||||
sec n = UTCTime (toEnum 0) (fromIntegral n)
|
||||
@@ -42,7 +44,7 @@ runTimed m = go (runMealy m id)
|
||||
where
|
||||
go _ [] = []
|
||||
go w ((s, a) : as) =
|
||||
case runIdentity (stepAuto w (Request (sec s) utc nil) a) of
|
||||
case runIdentity (stepAuto w (Request (sec s) utc nil "test") a) of
|
||||
(b, w') -> b : go w' as
|
||||
|
||||
-- | A minimal State monad for observing effectful arrows (e.g. whenA gating).
|
||||
@@ -52,7 +54,7 @@ instance Functor St where
|
||||
fmap f (St g) = St $ \s -> let (a, s') = g s in (f a, s')
|
||||
|
||||
instance Applicative St where
|
||||
pure a = St (\s -> (a, s))
|
||||
pure a = St (a,)
|
||||
St f <*> St x = St $ \s -> let (f', s') = f s; (a, s'') = x s' in (f' a, s'')
|
||||
|
||||
instance Monad St where
|
||||
@@ -165,7 +167,7 @@ lMergeSpec = describe "lMerge" $ do
|
||||
changesSpec :: Spec
|
||||
changesSpec = describe "changes" $ do
|
||||
it "first output is always Tick" $
|
||||
runPure changes "hello" !! 0 `shouldBe` Tick
|
||||
listToMaybe (runPure changes "hello") `shouldBe` Just Tick
|
||||
|
||||
it "outputs Event only on value change" $
|
||||
runPure changes "aaaabbbcca"
|
||||
@@ -535,11 +537,11 @@ sampleSpec = describe "sample" $ do
|
||||
|
||||
-- | A stateless arrow carrying a fixed entity set, for testing propagation.
|
||||
subscribed :: S.Set T.Text -> Mealy Identity Int Int
|
||||
subscribed ents = Mealy ents $ \_ -> Fun $ \_ a -> a
|
||||
subscribed ents = Mealy ents emptyDiagram $ \_ -> Fun $ \_ a -> a
|
||||
|
||||
-- | Same as 'subscribed' but yields a function, for testing '<*>'.
|
||||
subscribedF :: S.Set T.Text -> Mealy Identity Int (Int -> Int)
|
||||
subscribedF ents = Mealy ents $ \_ -> Fun $ \_ a -> (a +)
|
||||
subscribedF ents = Mealy ents emptyDiagram $ \_ -> Fun $ \_ a -> (a +)
|
||||
|
||||
entitiesSpec :: Spec
|
||||
entitiesSpec = describe "entities" $ do
|
||||
|
||||
+127
-24
@@ -5,7 +5,10 @@ module BedroomSpec (spec) where
|
||||
import AFRP (Event (..), entities)
|
||||
import qualified Data.Set as S
|
||||
import qualified Data.Text as T
|
||||
import Data.Aeson (Value)
|
||||
import Data.Aeson (Value, object, (.=))
|
||||
import qualified Data.Aeson.Key as Key
|
||||
import Data.Default (def)
|
||||
import Data.Time (getCurrentTime, addUTCTime)
|
||||
import HomeAssistant.Controller
|
||||
import HomeAssistant.Controller.Bedroom
|
||||
import Support
|
||||
@@ -20,11 +23,31 @@ enishenButton = Event . buttonEvent "event.bedroom_quick_jemina_action"
|
||||
drawerState :: T.Text -> Event Value
|
||||
drawerState = Event . stateEvent "binary_sensor.bedroom_nightstand_drawer_sensor_masse_contact"
|
||||
|
||||
presenceSensor :: T.Text -> Event Value
|
||||
presenceSensor = Event . stateEvent "binary_sensor.presence_sensor_bedroom_occupancy"
|
||||
|
||||
-- Light state event with observed attributes
|
||||
masseLight :: T.Text -> [(T.Text, Int)] -> Event Value
|
||||
masseLight state attrs = Event $ object
|
||||
[ "event" .= object
|
||||
[ "variables" .= object
|
||||
[ "trigger" .= object
|
||||
[ "entity_id" .= ("light.bedroom_masse" :: T.Text)
|
||||
, "to_state" .= object
|
||||
[ "state" .= state
|
||||
, "attributes" .= object [ Key.fromString (T.unpack k) .= v | (k, v) <- attrs ]
|
||||
]
|
||||
]
|
||||
]
|
||||
]
|
||||
]
|
||||
|
||||
spec :: Spec
|
||||
spec = describe "Bedroom" $ do
|
||||
entitySpec
|
||||
drawerSpec
|
||||
buttonSpec
|
||||
presenceSpec
|
||||
|
||||
entitySpec :: Spec
|
||||
entitySpec = describe "entities" $ do
|
||||
@@ -45,11 +68,12 @@ entitySpec = describe "entities" $ do
|
||||
`shouldBe` S.fromList
|
||||
[ "event.bedroom_quick_remote_masse_action"
|
||||
, "event.bedroom_quick_jemina_action"
|
||||
, "event.bedroom_remote_action"
|
||||
]
|
||||
|
||||
it "bedroomPresenceController subscribes to the presence sensor" $
|
||||
entities bedroomPresenceController
|
||||
`shouldBe` S.singleton "binary_sensor.presence_sensor_bedroom_occupancy"
|
||||
S.toList (entities bedroomPresenceController)
|
||||
`shouldContain` [ "binary_sensor.presence_sensor_bedroom_occupancy" ]
|
||||
|
||||
it "humidifierController subscribes to the door sensor" $
|
||||
entities humidifierController
|
||||
@@ -61,18 +85,18 @@ drawerSpec = describe "bedroomDrawerController" $ do
|
||||
|
||||
it "turns the drawer light on when the drawer opens" $
|
||||
services (runHASS bedroomDrawerController [drawerState "on"])
|
||||
`shouldBe` [[switch [entity] True]]
|
||||
`shouldBe` [[switchService [entity] [] True]]
|
||||
|
||||
it "turns the drawer light off when the drawer closes" $
|
||||
services (runHASS bedroomDrawerController [drawerState "off"])
|
||||
`shouldBe` [[switch [entity] False]]
|
||||
`shouldBe` [[switchService [entity] [] False]]
|
||||
|
||||
it "toggles the light as the drawer opens and closes" $
|
||||
services (runHASS bedroomDrawerController
|
||||
[ drawerState "on", drawerState "off", drawerState "on" ])
|
||||
`shouldBe` [ [switch [entity] True]
|
||||
, [switch [entity] False]
|
||||
, [switch [entity] True]
|
||||
`shouldBe` [ [switchService [entity] [] True]
|
||||
, [switchService [entity] [] False]
|
||||
, [switchService [entity] [] True]
|
||||
]
|
||||
|
||||
it "ignores state events for other entities" $
|
||||
@@ -84,41 +108,120 @@ drawerSpec = describe "bedroomDrawerController" $ do
|
||||
services (runHASS bedroomDrawerController [Tick])
|
||||
`shouldBe` [[]]
|
||||
|
||||
presenceSpec :: Spec
|
||||
presenceSpec = describe "bedroomPresenceController" $ do
|
||||
let sleepScene = activateScene "scene.makuuhuone_lepotila"
|
||||
|
||||
it "subscribes to presence, light level and the bedroom lights" $
|
||||
entities bedroomPresenceController
|
||||
`shouldBe` S.fromList
|
||||
[ "binary_sensor.presence_sensor_bedroom_occupancy"
|
||||
, "sensor.presence_sensor_bedroom_light_level"
|
||||
, "light.bedroom_ceiling"
|
||||
, "light.bedroom_jemina"
|
||||
, "light.bedroom_led_switch"
|
||||
, "light.bedroom_masse"
|
||||
]
|
||||
|
||||
it "does nothing on Tick" $
|
||||
services (runHASS bedroomPresenceController [Tick])
|
||||
`shouldBe` [[]]
|
||||
|
||||
it "does nothing when entering for the first time (no snapshot yet)" $
|
||||
services (runHASS bedroomPresenceController [presenceSensor "on"])
|
||||
`shouldBe` [[]]
|
||||
|
||||
it "activates the sleep scene when leaving with the lights on" $
|
||||
services (runHASS bedroomPresenceController
|
||||
[ presenceSensor "on", masseLight "on" [], presenceSensor "off" ])
|
||||
`shouldBe` [ [], [], [sleepScene] ]
|
||||
|
||||
it "does not activate the sleep scene when the lights are off" $
|
||||
services (runHASS bedroomPresenceController
|
||||
[ presenceSensor "on", masseLight "on" [], masseLight "off" [], presenceSensor "off" ])
|
||||
`shouldBe` [ [], [], [], [] ]
|
||||
|
||||
it "turns the lights off 300s after leaving" $ do
|
||||
now <- getCurrentTime
|
||||
let later = 305 `addUTCTime` now
|
||||
services (runHASSTimed bedroomPresenceController
|
||||
[ (now, presenceSensor "on"), (now, presenceSensor "off"), (later, Tick) ])
|
||||
`shouldBe` [ [], [], [light bedroomLightTargets [] Off] ]
|
||||
|
||||
it "restores the last snapshot when re-entering after sleep" $ do
|
||||
now <- getCurrentTime
|
||||
let later = 350 `addUTCTime` now
|
||||
let masseRestored = light [EntityId "light.bedroom_masse"] [] (On def
|
||||
{ lightBrightness = Just (BrightnessAbsolute 140)
|
||||
, lightColorTemperature = Just 2700
|
||||
})
|
||||
services (runHASSTimed bedroomPresenceController
|
||||
[ (now, presenceSensor "on")
|
||||
, (now, masseLight "on" [("brightness", 255), ("color_temp_kelvin", 2700)])
|
||||
, (now, presenceSensor "off")
|
||||
, (now, Tick)
|
||||
, (later, presenceSensor "on")
|
||||
, (later, Tick)
|
||||
])
|
||||
`shouldBe` [ []
|
||||
, []
|
||||
, [sleepScene]
|
||||
, []
|
||||
, [ light [EntityId "light.bedroom_ceiling"] [] Off
|
||||
, light [EntityId "light.bedroom_jemina"] [] Off
|
||||
, light [EntityId "light.bedroom_led_switch"] [] Off
|
||||
, masseRestored
|
||||
]
|
||||
, []
|
||||
]
|
||||
|
||||
buttonSpec :: Spec
|
||||
buttonSpec = describe "bedroomButtonController" $ do
|
||||
let area = AreaId "makuuhuone"
|
||||
|
||||
it "Masse single click turns on his nightstand scene (lowest)" $
|
||||
services (runHASS bedroomButtonController [masseButton "1_short_release"])
|
||||
`shouldBe` [[activateScene "scene.makuuhuone_masse"]]
|
||||
concat (services (runHASS bedroomButtonController [masseButton "1_short_release"]))
|
||||
`shouldContain` [activateScene "scene.makuuhuone_masse"]
|
||||
|
||||
it "Masse double click turns on the middle scene" $
|
||||
services (runHASS bedroomButtonController [masseButton "1_double_press"])
|
||||
`shouldBe` [[activateScene "scene.makuuhuone_keski"]]
|
||||
concat (services (runHASS bedroomButtonController [masseButton "1_double_press"]))
|
||||
`shouldContain` [activateScene "scene.makuuhuone_keski"]
|
||||
|
||||
it "Masse long click turns on the bright scene" $
|
||||
services (runHASS bedroomButtonController [masseButton "1_long_press"])
|
||||
`shouldBe` [[activateScene "scene.makuuhuone_kirkas"]]
|
||||
concat (services (runHASS bedroomButtonController [masseButton "1_long_press"]))
|
||||
`shouldContain` [activateScene "scene.makuuhuone_kirkas"]
|
||||
|
||||
it "Masse off click turns the bedroom lights off" $
|
||||
services (runHASS bedroomButtonController [masseButton "2_short_release"])
|
||||
`shouldBe` [[light [area] Off]]
|
||||
concat (services (runHASS bedroomButtonController [masseButton "2_short_release"]))
|
||||
`shouldContain` [light [area] [] Off]
|
||||
|
||||
it "Masse long off click also turns the hallway lights off" $
|
||||
concat (services (runHASS bedroomButtonController [masseButton "2_long_press"]))
|
||||
`shouldContain` [light [EntityId "light.hallway_lights"] [] Off]
|
||||
|
||||
it "Masse short off click leaves the hallway lights alone" $
|
||||
concat (services (runHASS bedroomButtonController [masseButton "2_short_release"]))
|
||||
`shouldNotContain` [light [EntityId "light.hallway_lights"] [] Off]
|
||||
|
||||
it "Enishen single click turns on her nightstand scene (lowest)" $
|
||||
services (runHASS bedroomButtonController [enishenButton "1_short_release"])
|
||||
`shouldBe` [[activateScene "scene.makuuhuone_jemina"]]
|
||||
concat (services (runHASS bedroomButtonController [enishenButton "1_short_release"]))
|
||||
`shouldContain` [activateScene "scene.makuuhuone_jemina"]
|
||||
|
||||
it "Enishen double click turns on the middle scene" $
|
||||
services (runHASS bedroomButtonController [enishenButton "1_double_press"])
|
||||
`shouldBe` [[activateScene "scene.makuuhuone_keski"]]
|
||||
concat (services (runHASS bedroomButtonController [enishenButton "1_double_press"]))
|
||||
`shouldContain` [activateScene "scene.makuuhuone_keski"]
|
||||
|
||||
it "Enishen long click turns on the bright scene" $
|
||||
services (runHASS bedroomButtonController [enishenButton "1_long_press"])
|
||||
`shouldBe` [[activateScene "scene.makuuhuone_kirkas"]]
|
||||
concat (services (runHASS bedroomButtonController [enishenButton "1_long_press"]))
|
||||
`shouldContain` [activateScene "scene.makuuhuone_kirkas"]
|
||||
|
||||
it "Enishen off click turns the bedroom lights off" $
|
||||
services (runHASS bedroomButtonController [enishenButton "2_short_release"])
|
||||
`shouldBe` [[light [area] Off]]
|
||||
concat (services (runHASS bedroomButtonController [enishenButton "2_short_release"]))
|
||||
`shouldContain` [light [area] [] Off]
|
||||
|
||||
it "Enishen long off click also turns the hallway lights off" $
|
||||
concat (services (runHASS bedroomButtonController [enishenButton "2_long_press"]))
|
||||
`shouldContain` [light [EntityId "light.hallway_lights"] [] Off]
|
||||
|
||||
it "ignores the initial press (scene only fires on release)" $
|
||||
services (runHASS bedroomButtonController [masseButton "1_initial_press"])
|
||||
|
||||
+42
-11
@@ -6,6 +6,7 @@ import AFRP (Request (..), Event (..))
|
||||
import Control.Concurrent.STM
|
||||
( atomically
|
||||
, dupTChan
|
||||
|
||||
, readTChan
|
||||
, writeTChan
|
||||
)
|
||||
@@ -15,9 +16,14 @@ import Data.Time (UTCTime (..), utc)
|
||||
import Data.UUID (nil)
|
||||
import HomeAssistant.Controller (HASSEff (..), Service (..), Target(..))
|
||||
import HomeAssistant.Runtime.Bus
|
||||
import HomeAssistant.Runtime.Flags (loadFlags, setEnabled)
|
||||
import HomeAssistant.Runtime.Metrics (registerAppMetrics)
|
||||
import Katip (Namespace (Namespace), runKatipContextT, Severity (..))
|
||||
import Katip (Namespace (Namespace), runKatipContextT)
|
||||
import Katip.Monadic (runNoLoggingT)
|
||||
import Support (withTestLogEnv)
|
||||
import qualified System.Metrics as Metrics
|
||||
import System.IO.Temp (withTempDirectory)
|
||||
import System.Timeout (timeout)
|
||||
import Test.Hspec
|
||||
|
||||
spec :: Spec
|
||||
@@ -33,13 +39,24 @@ spec = describe "Bus" $ do
|
||||
r2 `shouldBe` (Event (Number 1), Event (Number 2))
|
||||
|
||||
it "channelHassEval writes CallService to the outbound channel" $ withTestBus $ \bus -> do
|
||||
let req = Request (UTCTime (toEnum 0) 0) utc nil
|
||||
svc = Service "light" "turn_on" Nothing [EntityId "light.bedroom_masse"]
|
||||
let req = Request (UTCTime (toEnum 0) 0) utc nil "test"
|
||||
svc = Service "light" "turn_on" Nothing [EntityId "light.bedroom_masse"] []
|
||||
runKatipContextT (busLogEnv bus) () (Namespace ["test"]) $
|
||||
channelHassEval bus (CallService req svc)
|
||||
(_, svc') <- atomically $ readTChan (busOutbound bus)
|
||||
svc' `shouldBe` svc
|
||||
|
||||
it "channelHassEval writes CallService to the outbound channel even when the handler is disabled" $
|
||||
withTestFlagsBus $ \bus -> do
|
||||
setEnabled (busFlags bus) "test-handler" False
|
||||
let req = Request (UTCTime (toEnum 0) 0) utc nil "test-handler"
|
||||
svc = Service "light" "turn_on" Nothing [EntityId "light.test"] []
|
||||
runKatipContextT (busLogEnv bus) () (Namespace ["test"]) $
|
||||
channelHassEval bus (CallService req svc)
|
||||
result <- timeout 1000000 $ atomically $ readTChan (busOutbound bus)
|
||||
case result of
|
||||
Nothing -> expectationFailure "expected a write to the outbound channel"
|
||||
Just (_, svc') -> svc' `shouldBe` svc
|
||||
|
||||
it "generates unique sequential call ids" $ do
|
||||
gen <- mkCallIdGen 0
|
||||
@@ -51,16 +68,30 @@ spec = describe "Bus" $ do
|
||||
it "increments the trigger and service counters" $ do
|
||||
store <- Metrics.newStore
|
||||
m <- registerAppMetrics store
|
||||
withBus InfoS m $ \bus -> do
|
||||
recordInbound bus
|
||||
recordInbound bus
|
||||
recordOutbound bus
|
||||
sample <- Metrics.sampleAll store
|
||||
HM.lookup "hass.trigger.in" sample `shouldBe` Just (Metrics.Counter 2)
|
||||
HM.lookup "hass.service.out" sample `shouldBe` Just (Metrics.Counter 1)
|
||||
withTempDirectory "/tmp" "bus-spec" $ \dir -> do
|
||||
flags <- runNoLoggingT (loadFlags dir [])
|
||||
withTestLogEnv $ \le -> withBus le m flags $ \bus -> do
|
||||
recordInbound bus
|
||||
recordInbound bus
|
||||
recordOutbound bus
|
||||
sample <- Metrics.sampleAll store
|
||||
HM.lookup "hass.trigger.in" sample `shouldBe` Just (Metrics.Counter 2)
|
||||
HM.lookup "hass.service.out" sample `shouldBe` Just (Metrics.Counter 1)
|
||||
|
||||
withTestBus :: (Bus -> IO a) -> IO a
|
||||
withTestBus action = do
|
||||
store <- Metrics.newStore
|
||||
m <- registerAppMetrics store
|
||||
withBus InfoS m action
|
||||
withTestLogEnv $ \le ->
|
||||
withTempDirectory "/tmp" "bus-spec" $ \dir -> do
|
||||
flags <- runNoLoggingT (loadFlags dir [])
|
||||
withBus le m flags action
|
||||
|
||||
withTestFlagsBus :: (Bus -> IO a) -> IO a
|
||||
withTestFlagsBus action = do
|
||||
store <- Metrics.newStore
|
||||
m <- registerAppMetrics store
|
||||
withTestLogEnv $ \le ->
|
||||
withTempDirectory "/tmp" "bus-spec" $ \dir -> do
|
||||
flags <- runNoLoggingT (loadFlags dir ["test-handler"])
|
||||
withBus le m flags action
|
||||
+45
-7
@@ -4,19 +4,30 @@ module ConnectionSpec (spec) where
|
||||
|
||||
import AFRP (Request(..))
|
||||
import Data.Aeson (object, (.=))
|
||||
import qualified Data.HashMap.Strict as HM
|
||||
import Data.Maybe (fromJust)
|
||||
import Data.Text (Text)
|
||||
import Data.Time (UTCTime (..), utc)
|
||||
import Data.UUID (fromString)
|
||||
import HomeAssistant.Controller (Service (..), Target(..))
|
||||
import HomeAssistant.Runtime.Connection (encodeService, isTriggerEvent)
|
||||
import HomeAssistant.Runtime.Bus
|
||||
import HomeAssistant.Runtime.Flags (loadFlags, setEnabled)
|
||||
import HomeAssistant.Runtime.Metrics (registerAppMetrics)
|
||||
import HomeAssistant.Runtime.RateLimit (registerRateLimitMetrics, slidingWindowLimiter)
|
||||
import HomeAssistant.Runtime.Connection (dispatchService, encodeService, isTriggerEvent)
|
||||
import Katip (Namespace (Namespace), runKatipContextT)
|
||||
import Katip.Monadic (runNoLoggingT)
|
||||
import Support (withTestLogEnv)
|
||||
import System.IO.Temp (withTempDirectory)
|
||||
import qualified System.Metrics as Metrics
|
||||
import System.Timeout (timeout)
|
||||
import Test.Hspec
|
||||
|
||||
spec :: Spec
|
||||
spec = do
|
||||
describe "encodeService" $ do
|
||||
it "encodes a call_service message" $
|
||||
encodeService 7 (Service "light" "turn_on" Nothing [EntityId "light.bedroom_masse"])
|
||||
encodeService 7 (Service "light" "turn_on" Nothing [EntityId "light.bedroom_masse"] [])
|
||||
`shouldBe` object
|
||||
[ "id" .= (7 :: Int)
|
||||
, "type" .= ("call_service" :: Text)
|
||||
@@ -26,7 +37,7 @@ spec = do
|
||||
]
|
||||
|
||||
it "includes service_data when present" $
|
||||
encodeService 8 (Service "light" "turn_on" (Just (object ["brightness" .= (200 :: Int)])) [EntityId "light.bedroom_masse"])
|
||||
encodeService 8 (Service "light" "turn_on" (Just (object ["brightness" .= (200 :: Int)])) [EntityId "light.bedroom_masse"] [])
|
||||
`shouldBe` object
|
||||
[ "id" .= (8 :: Int)
|
||||
, "type" .= ("call_service" :: Text)
|
||||
@@ -36,6 +47,19 @@ spec = do
|
||||
, "service_data" .= object ["brightness" .= (200 :: Int)]
|
||||
]
|
||||
|
||||
it "encodes target exclusions" $
|
||||
encodeService 9 (Service "light" "turn_off" Nothing [AreaId "lasten_makuuhuone"] [LabelId "decoration"])
|
||||
`shouldBe` object
|
||||
[ "id" .= (9 :: Int)
|
||||
, "type" .= ("call_service" :: Text)
|
||||
, "domain" .= ("light" :: Text)
|
||||
, "service" .= ("turn_off" :: Text)
|
||||
, "target" .= object
|
||||
[ "area_id" .= ("lasten_makuuhuone" :: Text)
|
||||
, "exclude" .= object ["label_id" .= ("decoration" :: Text)]
|
||||
]
|
||||
]
|
||||
|
||||
describe "isTriggerEvent" $ do
|
||||
it "is true for event frames" $
|
||||
isTriggerEvent (object ["type" .= ("event" :: Text)]) `shouldBe` True
|
||||
@@ -44,16 +68,30 @@ spec = do
|
||||
it "is false when there is no type" $
|
||||
isTriggerEvent (object ["id" .= (1 :: Int)]) `shouldBe` False
|
||||
|
||||
describe "dispatchService" $ do
|
||||
it "skips disabled handlers without consuming a call id" $ do
|
||||
store <- Metrics.newStore
|
||||
m <- registerAppMetrics store
|
||||
rlMetrics <- registerRateLimitMetrics store
|
||||
limiter <- slidingWindowLimiter rlMetrics 10 20
|
||||
withTempDirectory "/tmp" "connection-spec" $ \dir -> do
|
||||
flags <- runNoLoggingT (loadFlags dir ["test"])
|
||||
setEnabled flags "test" False
|
||||
withTestLogEnv $ \le -> withBus le m flags $ \bus -> do
|
||||
timeout 1000000 (do
|
||||
runKatipContextT (busLogEnv bus) () (Namespace ["connection"]) $
|
||||
dispatchService limiter bus (req 1) (lightOn [EntityId "light.test"])
|
||||
generateCallId (busGen bus)) `shouldReturn` Just 1
|
||||
sample <- Metrics.sampleAll store
|
||||
HM.lookup "hass.service.out" sample `shouldBe` Just (Metrics.Counter 0)
|
||||
|
||||
req :: Int -> Request
|
||||
req n = Request (UTCTime (toEnum 0) (fromIntegral (0 :: Int))) utc
|
||||
(fromJust (fromString uuid))
|
||||
(fromJust (fromString uuid)) "test"
|
||||
where
|
||||
pad i = replicate (12 - length (show i)) '0' <> show i
|
||||
uuid = "00000000-0000-0000-0000-" <> pad n
|
||||
|
||||
lightOn :: [Target] -> Service
|
||||
lightOn targets = Service "light" "turn_on" Nothing targets
|
||||
lightOn targets = Service "light" "turn_on" Nothing targets []
|
||||
|
||||
lightOff :: [Target] -> Service
|
||||
lightOff targets = Service "light" "turn_off" Nothing targets
|
||||
@@ -0,0 +1,28 @@
|
||||
{-# LANGUAGE OverloadedStrings #-}
|
||||
module ControllerSpec where
|
||||
import Test.Hspec
|
||||
import Data.Default (def)
|
||||
import HomeAssistant.Controller (Brightness(..), formatLightAttributes, LightAttributes(..))
|
||||
import Data.Aeson (object, (.=))
|
||||
|
||||
|
||||
spec :: Spec
|
||||
spec = describe "Generic controller" $
|
||||
describe "Light settings" $ do
|
||||
it "formats the default as empty" $
|
||||
formatLightAttributes def `shouldBe` Nothing
|
||||
it "formats the transition" $
|
||||
formatLightAttributes def{lightTransition=Just 5} `shouldBe`
|
||||
Just (object ["transition" .= (5 :: Int)])
|
||||
it "formats the temperature" $
|
||||
formatLightAttributes def{lightColorTemperature=Just 5} `shouldBe`
|
||||
Just (object ["color_temp_kelvin" .= (5 :: Int)])
|
||||
it "formats the brightness as percentage" $
|
||||
formatLightAttributes def{lightBrightness=Just (BrightnessPercent 100)} `shouldBe`
|
||||
Just (object ["brightness_pct" .= (100 :: Int)])
|
||||
it "formats the brightness as absolute" $
|
||||
formatLightAttributes def{lightBrightness=Just (BrightnessAbsolute 200)} `shouldBe`
|
||||
Just (object ["brightness" .= (200 :: Int)])
|
||||
it "formats multiple values" $
|
||||
formatLightAttributes def{lightTransition = Just 5, lightBrightness=Just (BrightnessAbsolute 200)} `shouldBe`
|
||||
Just (object ["brightness" .= (200 :: Int), "transition" .= (5 :: Int)])
|
||||
@@ -0,0 +1,76 @@
|
||||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
module FlagsSpec (spec) where
|
||||
|
||||
import Control.Concurrent.Async (mapConcurrently_)
|
||||
import Control.Monad.IO.Class (liftIO)
|
||||
import Data.Aeson (decodeFileStrict)
|
||||
import Data.Map.Strict (Map)
|
||||
import qualified Data.Map.Strict as M
|
||||
import Data.Text (Text)
|
||||
import qualified Hedgehog.Gen as Gen
|
||||
import qualified Hedgehog.Range as Range
|
||||
import Katip.Monadic (runNoLoggingT)
|
||||
import System.IO.Temp (withTempDirectory)
|
||||
import Test.Hspec
|
||||
import Test.Hspec.Hedgehog
|
||||
|
||||
import HomeAssistant.Runtime.Flags
|
||||
|
||||
spec :: Spec
|
||||
spec = describe "Flags" $ do
|
||||
describe "loadFlags" $ do
|
||||
it "defaults all names to True when the file is missing (opt-out)" $
|
||||
withTempDirectory "/tmp" "flags-spec" $ \dir -> do
|
||||
flags <- runNoLoggingT (loadFlags dir ["a", "b"])
|
||||
m <- allFlags flags
|
||||
m `shouldBe` M.fromList [("a" :: Text, True), ("b", True)]
|
||||
|
||||
it "lets the file override the True default, missing keys stay True" $
|
||||
withTempDirectory "/tmp" "flags-spec" $ \dir -> do
|
||||
let path = dir <> "/handlers.json"
|
||||
writeFile path "{\"b\": false}"
|
||||
flags <- runNoLoggingT (loadFlags dir ["a", "b"])
|
||||
m <- allFlags flags
|
||||
m `shouldBe` M.fromList [("a" :: Text, True), ("b" :: Text, False)]
|
||||
|
||||
it "treats a corrupt file as empty (all-enabled) without throwing" $
|
||||
withTempDirectory "/tmp" "flags-spec" $ \dir -> do
|
||||
let path = dir <> "/handlers.json"
|
||||
writeFile path "not json at all"
|
||||
flags <- runNoLoggingT (loadFlags dir ["a"])
|
||||
m <- allFlags flags
|
||||
m `shouldBe` M.fromList [("a" :: Text, True)]
|
||||
|
||||
describe "isEnabled" $ do
|
||||
it "returns the stored value" $
|
||||
withTempDirectory "/tmp" "flags-spec" $ \dir -> do
|
||||
let path = dir <> "/handlers.json"
|
||||
writeFile path "{\"a\": false}"
|
||||
flags <- runNoLoggingT (loadFlags dir ["a"])
|
||||
isEnabled flags "a" `shouldReturn` False
|
||||
|
||||
it "defaults unknown names to True" $
|
||||
withTempDirectory "/tmp" "flags-spec" $ \dir -> do
|
||||
flags <- runNoLoggingT (loadFlags dir [])
|
||||
isEnabled flags "unknown" `shouldReturn` True
|
||||
|
||||
describe "setEnabled" $ do
|
||||
it "updates the in-memory map and persists to disk" $
|
||||
withTempDirectory "/tmp" "flags-spec" $ \dir -> do
|
||||
flags <- runNoLoggingT (loadFlags dir ["a"])
|
||||
setEnabled flags "a" False
|
||||
isEnabled flags "a" `shouldReturn` False
|
||||
-- reload from disk to confirm persistence
|
||||
flags' <- runNoLoggingT (loadFlags dir ["a"])
|
||||
isEnabled flags' "a" `shouldReturn` False
|
||||
|
||||
it "concurrent writes leave the file consistent with the TVar" $
|
||||
hedgehog $ do
|
||||
n <- forAll $ Gen.int (Range.linear 1 50)
|
||||
liftIO $ withTempDirectory "/tmp" "flags-spec" $ \dir -> do
|
||||
flags <- runNoLoggingT (loadFlags dir ["x"])
|
||||
mapConcurrently_ (setEnabled flags "x" . even) [1 .. n]
|
||||
m <- allFlags flags
|
||||
decoded <- decodeFileStrict (dir <> "/handlers.json")
|
||||
(decoded :: Maybe (Map Text Bool)) `shouldBe` Just m
|
||||
+19
-1
@@ -7,6 +7,7 @@ import qualified Data.ByteString as BS
|
||||
import HomeAssistant.Runtime.Graphing
|
||||
( GraphSpec (..)
|
||||
, Range (..)
|
||||
, Graph(..)
|
||||
, buildGraphArgs
|
||||
, graphs
|
||||
, lookupGraph
|
||||
@@ -20,15 +21,29 @@ import System.Directory (findExecutable, getTemporaryDirectory, removeFile)
|
||||
import System.Exit (ExitCode (..))
|
||||
import System.Process (readProcessWithExitCode)
|
||||
import Test.Hspec
|
||||
import Servant.API (FromHttpApiData(..), ToHttpApiData (..))
|
||||
|
||||
traffic :: GraphSpec
|
||||
traffic = case lookupGraph graphs "traffic" of
|
||||
traffic = case lookupGraph graphs Traffic of
|
||||
Just s -> s
|
||||
Nothing -> error "traffic graph is missing from the table"
|
||||
|
||||
spec :: Spec
|
||||
spec = do
|
||||
describe "Graph HttpApiData" $ do
|
||||
-- There's an enumerable amount of graphs, we can just enumerate through them all
|
||||
it "satisfies roundtrip property" $ do
|
||||
let modes = [minBound..maxBound]
|
||||
let got = map (parseQueryParam . toQueryParam @Graph) modes
|
||||
let wanted = map Right modes
|
||||
got `shouldBe` wanted
|
||||
describe "parseRange" $ do
|
||||
-- Fully enumerable
|
||||
it "the http-api-data satisfies roundtrip property" $ do
|
||||
let rs = [minBound..maxBound]
|
||||
let got = map (parseQueryParam . toQueryParam @Range) rs
|
||||
let wanted = map Right rs
|
||||
got `shouldBe` wanted
|
||||
it "accepts every suffix in the closed set" $
|
||||
map parseRange ["10m", "1h", "24h", "7d", "30d"]
|
||||
`shouldBe` [ Just TenMinutes
|
||||
@@ -124,3 +139,6 @@ spec = do
|
||||
out `shouldSatisfy` BS.isPrefixOf pngMagic
|
||||
)
|
||||
`finally` cleanup
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,291 @@
|
||||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
module HallwaySpec (spec) where
|
||||
|
||||
import AFRP (Event (..))
|
||||
import qualified Data.Text as T
|
||||
import Data.Aeson (Value, object, (.=))
|
||||
import Data.Bool (bool)
|
||||
import Data.Default (def)
|
||||
import Data.List (scanl')
|
||||
import Data.Time (UTCTime, addUTCTime)
|
||||
import HomeAssistant.Controller
|
||||
import HomeAssistant.Controller.Hallway
|
||||
import Support
|
||||
import Test.Hspec
|
||||
import Test.Hspec.Hedgehog
|
||||
import qualified Hedgehog.Gen as Gen
|
||||
import qualified Hedgehog.Range as Range
|
||||
|
||||
day, night :: UTCTime
|
||||
day = clock 10 0 -- 10:00, outside sleep hours
|
||||
night = clock 21 0 -- 21:00, inside sleep hours (20:30 - 07:30)
|
||||
|
||||
motionSensor :: T.Text -> Event Value
|
||||
motionSensor = Event . stateEvent "binary_sensor.hallway_movement_occupancy"
|
||||
|
||||
masterDoor :: T.Text -> Event Value
|
||||
masterDoor = Event . stateEvent "binary_sensor.makuuhuone_ovi_contact"
|
||||
|
||||
childrenDoor :: T.Text -> Event Value
|
||||
childrenDoor = Event . stateEvent "binary_sensor.lasten_makuuhuone_ovi_contact"
|
||||
|
||||
bedroomPresenceSensor :: T.Text -> Event Value
|
||||
bedroomPresenceSensor = Event . stateEvent "binary_sensor.presence_sensor_bedroom_occupancy"
|
||||
|
||||
-- A light turning on with a raw brightness value (0-255)
|
||||
bedroomLightEvent :: T.Text -> Int -> Event Value
|
||||
bedroomLightEvent entityId brightness = Event . object $
|
||||
[ "event" .= object
|
||||
[ "variables" .= object
|
||||
[ "trigger" .= object
|
||||
[ "entity_id" .= (entityId :: T.Text)
|
||||
, "to_state" .= object
|
||||
[ "state" .= ("on" :: T.Text)
|
||||
, "attributes" .= object [ "brightness" .= brightness ]
|
||||
]
|
||||
]
|
||||
]
|
||||
]
|
||||
]
|
||||
|
||||
-- Same shape as the generator in PresenceSpec: mostly short gaps (< 500s
|
||||
-- timeout), occasionally a 600s gap so presence can expire and the room can
|
||||
-- become unoccupied again.
|
||||
data TestEvent = TestEvent Int (Event Bool)
|
||||
deriving Show
|
||||
|
||||
genTestEvent :: Gen TestEvent
|
||||
genTestEvent = TestEvent
|
||||
<$> Gen.frequency [(8, Gen.integral (Range.linear 0 20)), (2, pure 600)]
|
||||
<*> Gen.frequency [(3, pure Tick), (1, Event <$> Gen.bool)]
|
||||
|
||||
-- | Presence and both of its presence-derived triggers, observed in lock-step
|
||||
-- over the same motion stream, so the triggers can be judged against the
|
||||
-- intermediate presence value at each step.
|
||||
presenceProbe :: HASS (Event Value) (Presence, Event (), Event ())
|
||||
presenceProbe = (,,) <$> hallwayPresence <*> lightsOnTrigger <*> lightsOffTrigger
|
||||
|
||||
-- | Expected firing steps: every step that *enters* `target`. The implicit
|
||||
-- state before the first step is Unoccupied — the room starts unoccupied —
|
||||
-- so an Unoccupied-trigger never fires at the first step.
|
||||
edgeSteps :: Presence -> [Presence] -> [Int]
|
||||
edgeSteps target ps =
|
||||
[ i
|
||||
| (i, (prev, p)) <- zip [0 ..] (zip (Unoccupied : ps) ps)
|
||||
, prev /= target
|
||||
, p == target
|
||||
]
|
||||
|
||||
|
||||
spec :: Spec
|
||||
spec = describe "Hallway" $ do
|
||||
lightsSpec
|
||||
presenceTransitionSpec
|
||||
modeTriggerSpec
|
||||
|
||||
presenceTransitionSpec :: Spec
|
||||
presenceTransitionSpec = describe "presenceTriggers" $
|
||||
it "fires exactly on the corresponding presence transitions" $ hedgehog $ do
|
||||
events <- forAll $ Gen.list (Range.linear 0 100) genTestEvent
|
||||
let steps = drop 1 $ scanl' (flip addUTCTime) day [fromIntegral t | TestEvent t _ <- events]
|
||||
timed = values (runHASSTimed presenceProbe
|
||||
(zipWith (\t (TestEvent _ e) ->
|
||||
(t, stateEvent "binary_sensor.hallway_movement_occupancy" . bool "off" "on" <$> e))
|
||||
steps events))
|
||||
presences = [p | (p, _, _) <- timed]
|
||||
onSteps = [i | (i, (_, Event (), _)) <- zip [0 ..] timed]
|
||||
offSteps = [i | (i, (_, _, Event ())) <- zip [0 ..] timed]
|
||||
onSteps === edgeSteps Occupied presences
|
||||
offSteps === edgeSteps Unoccupied presences
|
||||
cover 30 "at least one unoccupied -> occupied transition" (not (null onSteps))
|
||||
cover 30 "at least one occupied -> unoccupied transition" (not (null offSteps))
|
||||
|
||||
-- | Presence, the chosen mode and the mode-adjustment trigger observed in
|
||||
-- lock-step over the same event stream.
|
||||
modeProbe :: HASS (Event Value) (Presence, Mode, Event Mode)
|
||||
modeProbe = (,,) <$> hallwayPresence <*> mode <*> modeTrigger
|
||||
|
||||
data ModeAction
|
||||
= Motion Bool -- ^ @True@ is motion detected
|
||||
| MasterDoor Bool -- ^ @True@ is closed
|
||||
| ChildrenDoor Bool -- ^ @True@ is closed
|
||||
| BedroomPresence Bool -- ^ @True@ is someone in the parents' bedroom
|
||||
| BedroomLight (Maybe Int) -- ^ @Nothing@ is off, otherwise the brightness
|
||||
| Idle
|
||||
deriving Show
|
||||
|
||||
data ModeEvent = ModeEvent Int ModeAction
|
||||
deriving Show
|
||||
|
||||
genModeEvent :: Gen ModeEvent
|
||||
genModeEvent = ModeEvent
|
||||
<$> Gen.frequency [(6, Gen.integral (Range.linear 0 15)), (1, pure 900)]
|
||||
<*> Gen.frequency [(4, Motion <$> Gen.bool)
|
||||
,(2, MasterDoor <$> Gen.bool)
|
||||
,(2, ChildrenDoor <$> Gen.bool)
|
||||
,(1, BedroomPresence <$> Gen.bool)
|
||||
,(1, BedroomLight <$> Gen.choice [pure Nothing, pure (Just 25), pure (Just 230)])
|
||||
,(2, pure Idle)
|
||||
]
|
||||
|
||||
modeEventValue :: ModeAction -> Event Value
|
||||
modeEventValue (Motion b) = Event $ stateEvent "binary_sensor.hallway_movement_occupancy" (bool "off" "on" b)
|
||||
modeEventValue (MasterDoor b) = Event $ stateEvent "binary_sensor.makuuhuone_ovi_contact" (bool "off" "on" b)
|
||||
modeEventValue (ChildrenDoor b) = Event $ stateEvent "binary_sensor.lasten_makuuhuone_ovi_contact" (bool "off" "on" b)
|
||||
modeEventValue (BedroomPresence b) = Event $ stateEvent "binary_sensor.presence_sensor_bedroom_occupancy" (bool "off" "on" b)
|
||||
modeEventValue (BedroomLight b) = case b of
|
||||
Nothing -> Event $ stateEvent "light.bedroom_ceiling" "off"
|
||||
Just n -> bedroomLightEvent "light.bedroom_ceiling" n
|
||||
modeEventValue Idle = Tick
|
||||
|
||||
-- | The mode-adjustment trigger: the presence-based lights are already on
|
||||
-- (room occupied), the world changed which lights should be on, so adjust.
|
||||
-- The first observed mode is the baseline the lights-on trigger already
|
||||
-- acted on, so it is not an adjustment.
|
||||
modeTriggerSpec :: Spec
|
||||
modeTriggerSpec = describe "modeTrigger" $
|
||||
it "fires exactly on occupied steps that change the mode, tagged with the new mode" $ hedgehog $ do
|
||||
events <- forAll $ Gen.list (Range.linear 0 100) genModeEvent
|
||||
let steps = drop 1 $ scanl' (flip addUTCTime) (clock 20 0) [fromIntegral t | ModeEvent t _ <- events]
|
||||
timed = values (runHASSTimed modeProbe
|
||||
(zipWith (\t (ModeEvent _ a) -> (t, modeEventValue a)) steps events))
|
||||
modes = [m | (_, m, _) <- timed]
|
||||
-- The previous mode; at the first step it is the mode itself, since
|
||||
-- the first observed mode is the baseline the lights-on trigger
|
||||
-- already acted on, not an adjustment.
|
||||
prior = case modes of [] -> []; m0 : _ -> m0 : init modes
|
||||
expected =
|
||||
[ i
|
||||
| (i, (prevM, (p, m, _))) <- zip [0 ..] (zip prior timed)
|
||||
, prevM /= m
|
||||
, p == Occupied
|
||||
]
|
||||
suppressed =
|
||||
[ () | (prevM, (p, m, _)) <- zip prior timed
|
||||
, p == Unoccupied
|
||||
, prevM /= m
|
||||
]
|
||||
fired = [i | (i, (_, _, Event _)) <- zip [0 ..] timed]
|
||||
tags = [(i, tag) | (i, (_, _, Event tag)) <- zip [0 ..] timed]
|
||||
fired === expected
|
||||
tags === [(i, m) | i <- expected, let m = modes !! i]
|
||||
cover 25 "fires at least once" (not (null fired))
|
||||
cover 25 "suppressed a mode change while unoccupied" (not (null suppressed))
|
||||
cover 25 "reaches quiet mode" (Quiet `elem` modes)
|
||||
|
||||
|
||||
lightsSpec :: Spec
|
||||
lightsSpec = do
|
||||
describe "hallwayLightsController" $ do
|
||||
it "turns the full lights on when someone enters during daytime" $
|
||||
services (runHASSTimed hallwayLightsController [(day, motionSensor "on")])
|
||||
`shouldBe` [[light [EntityId "light.hallway_lights"] [] (On def)]]
|
||||
|
||||
it "turns the full lights on when someone enters during daytime preceding tick" $
|
||||
services (runHASSTimed hallwayLightsController [(day, Tick), (day, motionSensor "on")])
|
||||
`shouldBe` [[], [light [EntityId "light.hallway_lights"] [] (On def)]]
|
||||
|
||||
it "turns the lights off when everyone leaves, without sleep mode" $
|
||||
let later = 505 `addUTCTime` day
|
||||
in services (runHASSTimed hallwayLightsController
|
||||
[ (day, Tick)
|
||||
, (day, motionSensor "on")
|
||||
, (day, motionSensor "off")
|
||||
, (later, Tick)
|
||||
])
|
||||
`shouldBe` [ []
|
||||
, [light [EntityId "light.hallway_lights"] [] (On def)]
|
||||
, []
|
||||
, [light [EntityId "light.hallway_lights"] [] Off]
|
||||
]
|
||||
|
||||
it "turns on only the ceiling light when entering during sleep hours with a door open" $
|
||||
services (runHASSTimed hallwayLightsController
|
||||
[ (night, Tick)
|
||||
, (night, masterDoor "on")
|
||||
, (night, motionSensor "on")
|
||||
])
|
||||
`shouldBe` [ []
|
||||
, []
|
||||
, [light [EntityId "light.hallway_ceiling_2"] [] (On def)]
|
||||
]
|
||||
|
||||
it "leaves the lights unchanged when an empty bedroom door opens during sleep hours" $
|
||||
services (runHASSTimed hallwayLightsController
|
||||
[ (night, masterDoor "off") -- closed
|
||||
, (night, childrenDoor "off") -- closed
|
||||
, (night, motionSensor "on")
|
||||
, (night, masterDoor "on") -- opens, but nobody is ready to sleep there
|
||||
])
|
||||
`shouldBe` [ []
|
||||
, []
|
||||
, [light [EntityId "light.hallway_lights"] [] (On def)]
|
||||
, []
|
||||
]
|
||||
|
||||
it "keeps the full lights when an awake bedroom sits behind an open door" $
|
||||
services (runHASSTimed hallwayLightsController
|
||||
[ (night, masterDoor "on") -- open for the cats
|
||||
, (night, childrenDoor "off") -- closed
|
||||
, (night, bedroomPresenceSensor "on")
|
||||
, (night, bedroomLightEvent "light.bedroom_ceiling" 230)
|
||||
, (night, motionSensor "on")
|
||||
])
|
||||
`shouldBe` [ [], [], [], []
|
||||
, [light [EntityId "light.hallway_lights"] [] (On def)]
|
||||
]
|
||||
|
||||
it "protects an open bedroom door as soon as its light is dimmed down" $
|
||||
services (runHASSTimed hallwayLightsController
|
||||
[ (night, masterDoor "on") -- open for the cats
|
||||
, (night, childrenDoor "off") -- closed
|
||||
, (night, bedroomLightEvent "light.bedroom_ceiling" 230) -- still bright
|
||||
, (night, bedroomPresenceSensor "on")
|
||||
, (night, motionSensor "on")
|
||||
, (night, bedroomLightEvent "light.bedroom_ceiling" 25)
|
||||
])
|
||||
`shouldBe` [ [], [], [], []
|
||||
, [light [EntityId "light.hallway_lights"] [] (On def)]
|
||||
, [light [EntityId "light.hallway_ceiling"] [] Off]
|
||||
]
|
||||
|
||||
it "counts a barely lit bedroom as ready to sleep" $
|
||||
services (runHASSTimed hallwayLightsController
|
||||
[ (night, masterDoor "off") -- closed
|
||||
, (night, childrenDoor "off") -- closed
|
||||
, (night, bedroomPresenceSensor "on")
|
||||
, (night, bedroomLightEvent "light.bedroom_ceiling" 25)
|
||||
, (night, motionSensor "on")
|
||||
, (night, masterDoor "on") -- opens for the cats, someone ready to sleep
|
||||
])
|
||||
`shouldBe` [ [], [], [], []
|
||||
, [light [EntityId "light.hallway_lights"] [] (On def)]
|
||||
, [light [EntityId "light.hallway_ceiling"] [] Off]
|
||||
]
|
||||
|
||||
it "dims the lower light when an occupied bedroom door opens during sleep hours" $
|
||||
services (runHASSTimed hallwayLightsController
|
||||
[ (night, masterDoor "off") -- closed
|
||||
, (night, childrenDoor "off") -- closed
|
||||
, (night, bedroomPresenceSensor "on")
|
||||
, (night, motionSensor "on")
|
||||
, (night, masterDoor "on") -- opens for the cats, someone ready to sleep
|
||||
])
|
||||
`shouldBe` [ [], [], []
|
||||
, [light [EntityId "light.hallway_lights"] [] (On def)]
|
||||
, [light [EntityId "light.hallway_ceiling"] [] Off]
|
||||
]
|
||||
|
||||
it "turns the lower hallway light on when the doors close while presence is active" $
|
||||
services (runHASSTimed hallwayLightsController
|
||||
[ (night, masterDoor "on")
|
||||
, (night, motionSensor "on")
|
||||
, (night, masterDoor "off")
|
||||
, (night, childrenDoor "off")
|
||||
])
|
||||
`shouldBe` [ []
|
||||
, [light [EntityId "light.hallway_ceiling_2"] [] (On def)]
|
||||
, []
|
||||
, [light [EntityId "light.hallway_ceiling"] [] (On def)]
|
||||
]
|
||||
@@ -0,0 +1,64 @@
|
||||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
module HttpServerSpec (spec) where
|
||||
|
||||
import qualified Data.Map.Strict as M
|
||||
import Data.Text (Text)
|
||||
import qualified Data.Text as T
|
||||
import Data.Text.Lazy.Encoding (decodeUtf8)
|
||||
import qualified Data.Text.Lazy as TL
|
||||
import Lucid (Html, renderBS, toHtml)
|
||||
import Test.Hspec
|
||||
|
||||
import HomeAssistant.Runtime.Graphing (Range (..))
|
||||
import HttpServer
|
||||
|
||||
render :: Html () -> String
|
||||
render = TL.unpack . decodeUtf8 . renderBS
|
||||
|
||||
spec :: Spec
|
||||
spec = describe "HttpServer" $ do
|
||||
describe "flagRow" $ do
|
||||
it "renders the whole row so htmx can outerHTML-swap it" $
|
||||
render (flagRow "tea" True) `shouldContain` "<tr id=\"status-tea\">"
|
||||
|
||||
it "requests an outerHTML swap (htmx casing)" $
|
||||
render (flagRow "tea" True) `shouldContain` "hx-swap=\"outerHTML\""
|
||||
|
||||
it "displays on with a Disable button when enabled" $ do
|
||||
let html = render (flagRow "tea" True)
|
||||
html `shouldContain` "<td>on</td>"
|
||||
html `shouldContain` "value=\"Disable\""
|
||||
|
||||
it "displays off with an Enable button when disabled" $ do
|
||||
let html = render (flagRow "tea" False)
|
||||
html `shouldContain` "<td>off</td>"
|
||||
html `shouldContain` "value=\"Enable\""
|
||||
|
||||
describe "flagsPage" $ do
|
||||
let page = flagsPage (FlagsResponse (M.fromList [("tea" :: Text, True)]))
|
||||
it "uses the shared page shell with a style block" $
|
||||
render page `shouldContain` "<style"
|
||||
|
||||
it "has a header row" $ do
|
||||
let html = render page
|
||||
html `shouldContain` "<th>Name</th>"
|
||||
html `shouldContain` "<th>Value</th>"
|
||||
|
||||
it "carries each row id exactly once" $
|
||||
T.count "id=\"status-tea\"" (T.pack (render page)) `shouldBe` 1
|
||||
|
||||
describe "statsPage" $ do
|
||||
it "uses the shared page shell with a style block (full page)" $
|
||||
render (toHtml (statsPage Nothing Nothing)) `shouldContain` "<style"
|
||||
|
||||
it "serves a bare fragment for htmx requests" $ do
|
||||
let html = render (toHtml (statsPage (Just True) (Just OneDay)))
|
||||
html `shouldNotContain` "DOCTYPE"
|
||||
html `shouldContain` "<div id=\"stats\">"
|
||||
|
||||
it "range links swap the stats fragment in place" $ do
|
||||
let html = render (toHtml (statsPage Nothing (Just OneDay)))
|
||||
html `shouldContain` "hx-get=\"/stats?range=24h\""
|
||||
html `shouldContain` "hx-target=\"#stats\""
|
||||
html `shouldContain` "hx-push-url=\"true\""
|
||||
@@ -0,0 +1,53 @@
|
||||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
module KitchenSpec (spec) where
|
||||
|
||||
import AFRP (Event (..), entities)
|
||||
import qualified Data.Set as S
|
||||
import qualified Data.Text as T
|
||||
import Data.Aeson (Value)
|
||||
import HomeAssistant.Controller
|
||||
import HomeAssistant.Controller.Kitchen
|
||||
import Support
|
||||
import Test.Hspec
|
||||
import Data.Default (def)
|
||||
import Data.Time (getCurrentTime, addUTCTime)
|
||||
|
||||
-- Helper functions for creating test events
|
||||
testDinnerLightLevel :: Int -> Event Value
|
||||
testDinnerLightLevel level = Event (stateEvent "sensor.sijainti_keittio_light_level" (T.pack $ show level))
|
||||
|
||||
testDinnerPresence :: T.Text -> Event Value
|
||||
testDinnerPresence state = Event (stateEvent "binary_sensor.sijainti_keittio_occupancy" state)
|
||||
|
||||
spec :: Spec
|
||||
spec = describe "Kitchen" $ do
|
||||
dinnerTableSpec
|
||||
|
||||
dinnerTableSpec :: Spec
|
||||
dinnerTableSpec = describe "dinnerTableController" $ do
|
||||
it "subscribes to the light level sensor" $ do
|
||||
entities dinnerTableController
|
||||
`shouldBe` S.fromList ["sensor.sijainti_keittio_light_level", "binary_sensor.sijainti_keittio_occupancy"]
|
||||
|
||||
it "subscribes to the presence sensor" $ do
|
||||
entities dinnerTableController
|
||||
`shouldBe` S.fromList ["sensor.sijainti_keittio_light_level", "binary_sensor.sijainti_keittio_occupancy"]
|
||||
|
||||
it "turns lights on when presence is occupied and light level is low" $ do
|
||||
services (runHASS dinnerTableController [testDinnerLightLevel 10, testDinnerPresence "on"])
|
||||
`shouldBe` [[switchService [EntityId "switch.adaptive_lighting_ruokapoydan_valot_sleep_mode"] [] True], [switchService [EntityId "switch.adaptive_lighting_ruokapoydan_valot_sleep_mode"] [] False, light [EntityId "light.kitchen_dining_large"] [] (On def)]]
|
||||
|
||||
it "turns lights to sleep when presence is unoccupied" $ do
|
||||
now <- getCurrentTime
|
||||
services (runHASSTimed dinnerTableController [(now, testDinnerLightLevel 10), (now, testDinnerPresence "off")])
|
||||
`shouldBe` [[switchService [EntityId "switch.adaptive_lighting_ruokapoydan_valot_sleep_mode"] [] True], []]
|
||||
it "turns lights off when no presence for 300 seconds" $ do
|
||||
now <- getCurrentTime
|
||||
let later = 305 `addUTCTime` now
|
||||
services (runHASSTimed dinnerTableController [(now, testDinnerLightLevel 10), (now, testDinnerPresence "off"), (later, Tick)])
|
||||
`shouldBe` [[switchService [EntityId "switch.adaptive_lighting_ruokapoydan_valot_sleep_mode"] [] True], [], [switchService [EntityId "switch.adaptive_lighting_ruokapoydan_valot_sleep_mode"] [] False, light [EntityId "light.kitchen_dining_large"] [] Off]]
|
||||
|
||||
it "does nothing on Tick" $ do
|
||||
services (runHASS dinnerTableController [Tick])
|
||||
`shouldBe` [[switchService [EntityId "switch.adaptive_lighting_ruokapoydan_valot_sleep_mode"] [] True]]
|
||||
@@ -0,0 +1,43 @@
|
||||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
module LivingroomSpec (spec) where
|
||||
|
||||
import AFRP (Event (..))
|
||||
import Data.Time (UTCTime (..), fromGregorian)
|
||||
import HomeAssistant.Controller
|
||||
import HomeAssistant.Controller.Livingroom
|
||||
import Support
|
||||
import Test.Hspec
|
||||
|
||||
-- | A UTCTime at a given hour on March 15, 2025 (Spring).
|
||||
springAt :: Int -> UTCTime
|
||||
springAt h = UTCTime (fromGregorian 2025 3 15) (fromIntegral (h * 3600))
|
||||
|
||||
-- | A UTCTime at a given hour on July 15, 2025 (Summer).
|
||||
summerAt :: Int -> UTCTime
|
||||
summerAt h = UTCTime (fromGregorian 2025 7 15) (fromIntegral (h * 3600))
|
||||
|
||||
spec :: Spec
|
||||
spec = describe "livingroomPlantLights" $ do
|
||||
it "activates the Growth scene at 10:00 in Spring" $ do
|
||||
let result = runHASSTimed livingroomPlantLights
|
||||
[ (springAt 9, Tick)
|
||||
, (springAt 10, Tick)
|
||||
]
|
||||
services result
|
||||
`shouldBe` [ [], [activateScene "scene.olohuoneen_kasvivalo"] ]
|
||||
|
||||
it "activates the Ambience scene at 20:00 in Spring" $ do
|
||||
let result = runHASSTimed livingroomPlantLights
|
||||
[ (springAt 19, Tick)
|
||||
, (springAt 20, Tick)
|
||||
]
|
||||
services result
|
||||
`shouldBe` [ [], [activateScene "scene.kasvivalo_iltatila"] ]
|
||||
|
||||
it "does not activate Growth in Summer" $ do
|
||||
let result = runHASSTimed livingroomPlantLights
|
||||
[ (summerAt 9, Tick)
|
||||
, (summerAt 10, Tick)
|
||||
]
|
||||
services result `shouldBe` [ [], [] ]
|
||||
@@ -6,9 +6,16 @@ import qualified AFRPSpec
|
||||
import qualified BedroomSpec
|
||||
import qualified BusSpec
|
||||
import qualified ConnectionSpec
|
||||
import qualified FlagsSpec
|
||||
import qualified GraphingSpec
|
||||
import qualified HallwaySpec
|
||||
import qualified HttpServerSpec
|
||||
import qualified KitchenSpec
|
||||
import qualified LivingroomSpec
|
||||
import qualified MetricsSpec
|
||||
import qualified RuntimeSpec
|
||||
import qualified ControllerSpec
|
||||
import qualified PresenceSpec
|
||||
|
||||
main :: IO ()
|
||||
main = hspec $ do
|
||||
@@ -17,6 +24,13 @@ main = hspec $ do
|
||||
BedroomSpec.spec
|
||||
BusSpec.spec
|
||||
ConnectionSpec.spec
|
||||
FlagsSpec.spec
|
||||
GraphingSpec.spec
|
||||
HallwaySpec.spec
|
||||
HttpServerSpec.spec
|
||||
KitchenSpec.spec
|
||||
LivingroomSpec.spec
|
||||
MetricsSpec.spec
|
||||
RuntimeSpec.spec
|
||||
ControllerSpec.spec
|
||||
PresenceSpec.spec
|
||||
+1
-1
@@ -147,7 +147,7 @@ spec = do
|
||||
parseInfoDs "step = 10\nrra[0].cf = \"AVERAGE\"\n" `shouldBe` []
|
||||
|
||||
describe "schemaMatches" $ do
|
||||
let ds name ty = DsSpec (T.pack name) name ty
|
||||
let ds name = DsSpec (T.pack name) name
|
||||
it "is true for identical schemas regardless of order" $
|
||||
schemaMatches [ds "b" Gauge, ds "a" Derive] [("a", Derive), ("b", Gauge)]
|
||||
`shouldBe` True
|
||||
|
||||
@@ -0,0 +1,53 @@
|
||||
{-# LANGUAGE OverloadedStrings #-}
|
||||
module PresenceSpec where
|
||||
import Test.Hspec (Spec, describe, shouldBe, it)
|
||||
import HomeAssistant.Controller (motion, motionToPresence, HASS, Presence(..))
|
||||
import Control.Arrow ((>>>))
|
||||
import Data.Aeson (Value)
|
||||
import Support
|
||||
import Data.Time (UTCTime)
|
||||
import AFRP (Event(..))
|
||||
import qualified Data.Text as T
|
||||
import Test.Hspec.Hedgehog
|
||||
import qualified Hedgehog.Gen as Gen
|
||||
import qualified Hedgehog.Range as Range
|
||||
import Data.Time.Clock (addUTCTime, diffUTCTime)
|
||||
import Data.List (scanl')
|
||||
import Data.Bool (bool)
|
||||
|
||||
motionSensor :: T.Text -> Event Value
|
||||
motionSensor = Event . stateEvent "sensor.foo"
|
||||
|
||||
day :: UTCTime
|
||||
day = clock 10 0 -- 10:00, outside sleep hours
|
||||
|
||||
sut :: HASS (Event Value) Presence
|
||||
sut = motion "sensor.foo" >>> motionToPresence 500
|
||||
|
||||
data TestEvent = TestEvent Int (Event Bool)
|
||||
deriving Show
|
||||
|
||||
genTestEvent :: Gen TestEvent
|
||||
genTestEvent = TestEvent
|
||||
<$> Gen.frequency [(8, Gen.integral (Range.linear 0 20)), (2, pure 600)]
|
||||
<*> Gen.frequency [(3, pure Tick), (1, Event <$> Gen.bool)]
|
||||
|
||||
spec :: Spec
|
||||
spec = describe "Presence" $ do
|
||||
it "Starts as unoccupied" $
|
||||
values (runHASSTimed sut [(day, Tick)]) `shouldBe` [Unoccupied]
|
||||
it "Detection motion means presence" $ do
|
||||
values (runHASSTimed sut [(day, motionSensor "on")]) `shouldBe` [Occupied]
|
||||
values (runHASSTimed sut [(day, Tick), (day, motionSensor "on")]) `shouldBe` [Unoccupied, Occupied]
|
||||
it "Leaving doesn't mean immediately unoccupied room" $ do
|
||||
values (runHASSTimed sut [(day, motionSensor "on"), (day, motionSensor "off")]) `shouldBe` [Occupied, Occupied]
|
||||
it "re-detects occupancy only after the timeout since the previous detection" $ hedgehog $ do
|
||||
events <- forAll $ Gen.list (Range.linear 0 100) genTestEvent
|
||||
let steps = drop 1 $ scanl' (flip addUTCTime) day [fromIntegral t | TestEvent t _ <- events]
|
||||
length steps === length events
|
||||
let timed = zip steps (values (runHASSTimed sut (zipWith (\t (TestEvent _ e) -> (t, stateEvent "sensor.foo" . bool "off" "on" <$> e)) steps events)))
|
||||
let transitions = [() | ((_, Occupied), (_, Unoccupied)) <- zip timed (drop 1 timed)]
|
||||
cover 20 "occupied -> unoccupied transition" (not (null transitions))
|
||||
let starts = [t | (Unoccupied, (t, Occupied)) <- zip (Unoccupied : map snd timed) timed]
|
||||
let deltas = zipWith (\a b -> b `diffUTCTime` a) starts (drop 1 starts)
|
||||
(null deltas || minimum deltas > 500) === True
|
||||
+37
-3
@@ -4,23 +4,29 @@ module Support
|
||||
( Acc(..)
|
||||
, interp
|
||||
, runHASS
|
||||
, runHASSTimed
|
||||
, services
|
||||
, values
|
||||
, fakeRequest
|
||||
, sec
|
||||
, stateEvent
|
||||
, buttonEvent
|
||||
, withTestLogEnv
|
||||
, clock
|
||||
) where
|
||||
|
||||
import Control.Exception (bracket)
|
||||
import Control.Monad.Fix (MonadFix (..))
|
||||
import Data.Aeson (Value, object, (.=))
|
||||
import Katip (LogEnv, closeScribes, initLogEnv)
|
||||
import qualified Data.Text as T
|
||||
import Data.Time (UTCTime (..), utc)
|
||||
import Data.UUID (nil)
|
||||
import AFRP (Mealy (..), Request (..), stepAuto)
|
||||
import AFRP (Mealy (..), Request (..), stepAuto, Event (..))
|
||||
import HomeAssistant.Controller (HASSEff (..), Service)
|
||||
|
||||
fakeRequest :: Request
|
||||
fakeRequest = Request (sec 0) utc nil
|
||||
fakeRequest = Request (sec 0) utc nil "test"
|
||||
|
||||
sec :: Integer -> UTCTime
|
||||
sec n = UTCTime (toEnum 0) (fromIntegral n)
|
||||
@@ -32,7 +38,7 @@ instance Functor Acc where
|
||||
fmap f (Acc g) = Acc $ \s -> let (a, s') = g s in (f a, s')
|
||||
|
||||
instance Applicative Acc where
|
||||
pure a = Acc (\s -> (a, s))
|
||||
pure a = Acc (a,)
|
||||
Acc f <*> Acc x = Acc $ \s -> let (f', s') = f s; (a, s'') = x s' in (f' a, s'')
|
||||
|
||||
instance Monad Acc where
|
||||
@@ -41,9 +47,14 @@ instance Monad Acc where
|
||||
instance MonadFix Acc where
|
||||
mfix f = Acc $ \s -> let (a, s') = runAcc (f a) s in (a, s')
|
||||
|
||||
-- | A silent LogEnv: no scribes registered, so nothing is written anywhere.
|
||||
withTestLogEnv :: (LogEnv -> IO a) -> IO a
|
||||
withTestLogEnv = bracket (initLogEnv "test" "test") closeScribes
|
||||
|
||||
-- | Interpret `HASSEff` in `Acc`: record `CallService`, drop tracing/debug.
|
||||
interp :: HASSEff a -> Acc a
|
||||
interp (CallService _ svc) = Acc $ \s -> ((), s ++ [svc])
|
||||
interp (CallServices _ svc) = Acc $ \s -> ((), s ++ svc)
|
||||
interp (Debug _) = pure ()
|
||||
interp (Trace _ _) = pure ()
|
||||
|
||||
@@ -56,9 +67,24 @@ runHASS m = go (runMealy m interp)
|
||||
case runAcc (stepAuto w fakeRequest a) [] of
|
||||
((b, w'), svcs) -> (b, svcs) : go w' as
|
||||
|
||||
-- | Run a HASS arrow over a list of (time, input) pairs, collecting per-step
|
||||
-- emitted services. Each step uses a fresh Request with the given UTCTime.
|
||||
runHASSTimed :: Mealy HASSEff (Event a) b -> [(UTCTime, Event a)] -> [(b, [Service])]
|
||||
runHASSTimed m = go (runMealy m interp)
|
||||
where
|
||||
go _ [] = []
|
||||
go w ((t, a) : as) =
|
||||
case runAcc (stepAuto w (Request t utc nil "test") a) [] of
|
||||
((b, w'), svcs) -> (b, svcs) : go w' as
|
||||
|
||||
-- To observe external effects
|
||||
services :: [(b, [Service])] -> [[Service]]
|
||||
services = map snd
|
||||
|
||||
-- To observe intermediary steps
|
||||
values :: [(b, [Service])] -> [b]
|
||||
values = map fst
|
||||
|
||||
-- | Build a state-trigger payload matching `entityChangeEvent'` / `entityBool'`
|
||||
-- lenses. The subscribe_trigger websocket event wraps the trigger datum under
|
||||
-- `event.variables.trigger`, with `entity_id` and `to_state.state` fields.
|
||||
@@ -87,3 +113,11 @@ buttonEvent entityId eventType = object
|
||||
]
|
||||
]
|
||||
]
|
||||
|
||||
|
||||
|
||||
-- runHASSTimed builds its request with the UTC zone, so a UTCTime given as
|
||||
-- seconds-of-day reads back as exactly that local time of day
|
||||
clock :: Int -> Int -> UTCTime
|
||||
clock h m = sec (fromIntegral (h * 60 + m) * 60)
|
||||
|
||||
Reference in new issue
Block a user