Removed background poller processes

No longer necessary now that these have been converted into jobs managed by our worker service.

Milestone: minor
This commit is contained in:
Brooke Kuhlmann
2026-01-06 11:04:09 -07:00
parent ae152f63b2
commit 31ec83b34f
13 changed files with 0 additions and 379 deletions
-3
View File
@@ -1,6 +1,3 @@
web: bundle exec puma --config ./config/puma.rb
assets: bundle exec hanami assets watch
worker: bundle exec sidekiq -r ./config/sidekiq.rb
firmware_poller: bin/pollers/firmware
screen_poller: bin/pollers/screen
model_poller: bin/pollers/model
-3
View File
@@ -2,6 +2,3 @@ web: bundle exec puma --config ./config/puma.rb
assets: bundle exec hanami assets compile
migrate: bundle exec hanami db migrate
worker: bundle exec sidekiq -r ./config/sidekiq.rb
firmware_poller: bin/pollers/firmware
screen_poller: bin/pollers/screen
model_poller: bin/pollers/model
-43
View File
@@ -1,43 +0,0 @@
# frozen_string_literal: true
require "dry/monads"
require "initable"
module Terminus
module Aspects
module Firmware
# Polls the Core Firmware API on a scheduled interval for new firmware versions.
class Poller
include Deps[:settings, "aspects.firmware.synchronizer"]
include Initable[kernel: Kernel]
include Dry::Monads[:result]
# Seconds equates to six hours (60 * 60 * 6).
def call seconds: 21_600
watch_for_shudown
keep_alive seconds
end
private
def watch_for_shudown
kernel.trap "INT" do
kernel.puts "Gracefully shutting down firmware polling..."
kernel.exit
end
end
def keep_alive seconds
kernel.loop do
sync_or_skip
kernel.sleep seconds
end
end
def sync_or_skip
settings.firmware_poller ? synchronizer.call : kernel.puts("Firmware polling disabled.")
end
end
end
end
end
-43
View File
@@ -1,43 +0,0 @@
# frozen_string_literal: true
require "dry/monads"
require "initable"
module Terminus
module Aspects
module Models
# Polls the Core Models API on a scheduled interval for new (or updated) models.
class Poller
include Deps[:settings, "aspects.models.synchronizer"]
include Initable[kernel: Kernel]
include Dry::Monads[:result]
# Seconds equates to 1 day (60 * 60 * 24).
def call seconds: 86_400
watch_for_shudown
keep_alive seconds
end
private
def watch_for_shudown
kernel.trap "INT" do
kernel.puts "Gracefully shutting down model polling..."
kernel.exit
end
end
def keep_alive seconds
kernel.loop do
sync_or_skip
kernel.sleep seconds
end
end
def sync_or_skip
settings.model_poller ? synchronizer.call : kernel.puts("Model polling disabled.")
end
end
end
end
end
-54
View File
@@ -1,54 +0,0 @@
# frozen_string_literal: true
require "dry/monads"
require "initable"
module Terminus
module Aspects
module Screens
# Polls the Core Display API on a scheduled interval for new images to display locally.
class Poller
include Deps[
:settings,
:trmnl_api,
"aspects.screens.synchronizer",
repository: "repositories.device"
]
include Initable[kernel: Kernel]
include Dry::Monads[:result]
# Seconds equates to five minutes (60 * 5).
def call seconds: 300
watch_for_shudown
keep_alive seconds
end
private
def watch_for_shudown
kernel.trap "INT" do
kernel.puts "Gracefully shutting down screen polling..."
kernel.exit
end
end
def keep_alive seconds
kernel.loop do
sync_or_skip
kernel.sleep seconds
end
end
def sync_or_skip
settings.screen_poller ? process_devices : kernel.puts("Screen polling disabled.")
end
def process_devices = repository.all.select(&:proxy).each { |device| sync device }
def sync device
trmnl_api.display(token: device.api_key).bind { |record| synchronizer.call record }
end
end
end
end
end
-10
View File
@@ -1,10 +0,0 @@
#! /usr/bin/env ruby
# frozen_string_literal: true
require "bundler/setup"
Bundler.require :tools
require "hanami/prepare"
poller = Hanami.app["aspects.firmware.poller"]
poller.call
-10
View File
@@ -1,10 +0,0 @@
#! /usr/bin/env ruby
# frozen_string_literal: true
require "bundler/setup"
Bundler.require :tools
require "hanami/prepare"
poller = Hanami.app["aspects.models.poller"]
poller.call
-10
View File
@@ -1,10 +0,0 @@
#! /usr/bin/env ruby
# frozen_string_literal: true
require "bundler/setup"
Bundler.require :tools
require "hanami/prepare"
poller = Hanami.app["aspects.screens.poller"]
poller.call
-5
View File
@@ -9,9 +9,4 @@ ENV["LD_PRELOAD"] = jemalloc_path.first unless ENV.key?("LD_PRELOAD") || jemallo
system "bundle exec hanami assets compile"
system "bundle exec hanami db migrate"
%w[firmware screen model].each do |poller|
pid = spawn "bin/pollers/#{poller}"
Process.detach pid
end
exec(*ARGV)
-4
View File
@@ -8,8 +8,4 @@ IFS=$'\n\t'
cd /app
./bin/setup
for poller in firmware screen model; do
./bin/pollers/"$poller" &
done
exec "$@"
-50
View File
@@ -1,50 +0,0 @@
# frozen_string_literal: true
require "hanami_helper"
RSpec.describe Terminus::Aspects::Firmware::Poller do
subject(:poller) { described_class.new synchronizer:, kernel: }
let(:synchronizer) { instance_spy Terminus::Aspects::Firmware::Synchronizer }
let(:kernel) { class_spy Kernel, sleep: 0 }
include_context "with application dependencies"
describe "#call" do
before { allow(kernel).to receive(:loop).and_yield }
it "prints shutting down when CONTROL+C is used" do
allow(kernel).to receive(:trap).and_yield
poller.call
expect(kernel).to have_received(:puts).with(/shutting down/)
end
it "gracefully exists when CONTROL+C is used" do
allow(kernel).to receive(:trap).and_yield
poller.call
expect(kernel).to have_received(:exit)
end
it "synchronizes" do
poller.call
expect(synchronizer).to have_received(:call)
end
context "when disabled" do
before do
allow(settings).to receive(:firmware_poller).and_return false
poller.call
end
it "prints message" do
expect(kernel).to have_received(:puts).with("Firmware polling disabled.")
end
it "doesn't synchronize" do
expect(synchronizer).not_to have_received(:call)
end
end
end
end
-50
View File
@@ -1,50 +0,0 @@
# frozen_string_literal: true
require "hanami_helper"
RSpec.describe Terminus::Aspects::Models::Poller do
subject(:poller) { described_class.new synchronizer:, kernel: }
let(:synchronizer) { instance_spy Terminus::Aspects::Models::Synchronizer }
let(:kernel) { class_spy Kernel, sleep: 0 }
include_context "with application dependencies"
describe "#call" do
before { allow(kernel).to receive(:loop).and_yield }
it "prints shutting down when CONTROL+C is used" do
allow(kernel).to receive(:trap).and_yield
poller.call
expect(kernel).to have_received(:puts).with(/shutting down/)
end
it "gracefully exists when CONTROL+C is used" do
allow(kernel).to receive(:trap).and_yield
poller.call
expect(kernel).to have_received(:exit)
end
it "synchronizes" do
poller.call
expect(synchronizer).to have_received(:call)
end
context "when disabled" do
before do
allow(settings).to receive(:model_poller).and_return false
poller.call
end
it "prints message" do
expect(kernel).to have_received(:puts).with("Model polling disabled.")
end
it "doesn't synchronize" do
expect(synchronizer).not_to have_received(:call)
end
end
end
end
-94
View File
@@ -1,94 +0,0 @@
# frozen_string_literal: true
require "hanami_helper"
require "trmnl/api"
RSpec.describe Terminus::Aspects::Screens::Poller, :db do
subject(:poller) { described_class.new trmnl_api:, synchronizer:, kernel: }
let(:trmnl_api) { instance_spy TRMNL::API::Client, display: Success(display) }
let(:kernel) { class_spy Kernel, sleep: nil }
let :display do
TRMNL::API::Models::Display[image_url: "https://test.io/test.bmp", filename: "test.bmp"]
end
let(:synchronizer) { instance_spy Terminus::Aspects::Screens::Synchronizer }
include_context "with application dependencies"
describe "#call" do
let(:devices) { [Factory[:device, proxy: true]] }
before do
devices
allow(kernel).to receive(:loop).and_yield
end
it "prints that it's shutting down when CONTROL+C is used" do
allow(kernel).to receive(:trap).and_yield
poller.call
expect(kernel).to have_received(:puts).with(/shutting down/)
end
it "gracefully exists when CONTROL+C is used" do
allow(kernel).to receive(:trap).and_yield
poller.call
expect(kernel).to have_received(:exit)
end
it "requests image for device API key" do
poller.call
expect(trmnl_api).to have_received(:display)
end
it "synchronizes" do
poller.call
expect(synchronizer).to have_received(:call).with(display)
end
context "with no devices" do
let(:devices) { [] }
it "doesn't synchronize" do
poller.call
expect(synchronizer).not_to have_received(:call)
end
end
context "with no proxied devices" do
let(:devices) { [Factory[:device]] }
it "doesn't synchronize" do
poller.call
expect(synchronizer).not_to have_received(:call)
end
end
context "with remote image failure" do
let(:trmnl_api) { instance_spy TRMNL::API::Client, display: Failure("Danger!") }
it "doesn't synchronize" do
poller.call
expect(synchronizer).not_to have_received(:call)
end
end
context "when disabled" do
before do
allow(settings).to receive(:screen_poller).and_return false
poller.call
end
it "prints message" do
expect(kernel).to have_received(:puts).with("Screen polling disabled.")
end
it "doesn't synchronize" do
expect(synchronizer).not_to have_received(:call)
end
end
end
end