foreman-export-systemd_user 0.1.2 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11f74fdac3bd7a100d7661abf975e439c516aa2a9b591c819e83724a022cbb86
-  data.tar.gz: 7f5ba20c33815b77088d66c61b1ca80569703d95931de546b51d2ee3fd4c91d0
+  metadata.gz: b03ca222cc9bdd5faeb5b83d7502e8a474b0f17757027069a61d1ea371b97d34
+  data.tar.gz: b4ab848e3daff0171b3abac450a5927c978e7801e7f51c52bb3aa182855cb554
 SHA512:
-  metadata.gz: 045717c6c7544c2c9e8ff61ce91d2b508a336b3697a562309f270ee0b9563ffe6195c1d9adb999c9e1075eea69b19d15c679ff498aa0cacc1db2deb43e740ddd
-  data.tar.gz: 0b7dbf5081e562db851a87477df944135cc405df90bc71457bda8f2ca52d972f52adac893daeba960cfe1d5496271aaced427159b440748ca2d7d32f705f9b22
+  metadata.gz: 3d4e520fa7e89e7f0b09767eac6a0a00baf2f941d04e9e33e3bee9dd35cfe6bc438b8eaf761056c18d68f1a3f2f94bd6b9331d6ed9d64bf772f85ebcb2225914
+  data.tar.gz: cc120ed2047d131e3da8fc7c37be10adf9abf2d7d104d7e8804503f5021d580b7cf8b87c8c0a512a22f2f3bf7ed52ed16f18f42cb5f1f3db5ed59b6f923b33e4

data/.github/workflows/ci.yml

@@ -0,0 +1,27 @@
+name: CI
+
+on: [push, pull_request]
+
+jobs:
+  test:
+    runs-on: ubuntu-22.04
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 3.3
+          bundler-cache: true
+
+      - name: Install podman
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y podman
+
+      - name: Install dependencies
+        run: bundle install
+
+      - name: Run tests
+        run: bundle exec rspec

data/README.md

@@ -1,4 +1,4 @@
-# Foreman export scripts for user-level systemd on Ubuntu 16.04+
+# Foreman export scripts for user-level systemd
 
 ```ruby
 # Gemfile
@@ -11,11 +11,34 @@ then
 bundle exec foreman export systemd-user --app <app-name>
 ```
 
-Note that this may break from foreman's protocol a bit, because it starts the processes after export. It does this by running the following:
+After export, this runs the following to configure systemd:
 ```
+systemctl --user daemon-reload
 loginctl enable-linger
 systemctl --user enable <app-name>.target
+```
+
+To start or restart your services after export:
+```
 systemctl --user restart <app-name>.target
 ```
-After forgetting to run these steps enough times, I just decided to bake it into the export.
+
+## Including extra systemd files
+
+Use `--include-dir` to copy additional systemd files (drop-in overrides, extra units, timers) after generating the main units:
+
+```
+bundle exec foreman export systemd-user --app <app-name> --include-dir Procfile.systemd
+```
+
+Example directory structure:
+```
+Procfile.systemd/
+  <app-name>-web@.service.d/
+    override.conf           # Drop-in override for the web service
+  <app-name>-restart.service  # Extra standalone unit
+  <app-name>-restart.timer    # Timer (will be enabled and started automatically)
+```
+
+Any `.timer` files in the root of the include directory will be enabled with `--now`.
 

data/Rakefile

@@ -1,2 +1,7 @@
 #!/usr/bin/env rake
 require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/foreman

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "rubygems"
+require "foreman/cli"
+require "foreman-export-systemd_user"
+
+# Add --include-dir option to foreman export command
+Foreman::CLI.class_eval do
+  option = Thor::Option.new(:include_dir, type: :string, desc: "Directory of additional systemd files to copy")
+  export_command = commands["export"]
+  export_command.options[:include_dir] = option
+end
+
+Foreman::CLI.start

data/bin/setup

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+echo "==> Installing gem dependencies..."
+bundle install
+
+echo "==> Building test container image..."
+podman build -t foreman-export-systemd-user-test -f spec/Dockerfile.systemd spec/
+
+echo "==> Setup complete! Run 'bundle exec rake spec' to run tests."

data/foreman-export-systemd_user.gemspec

@@ -2,17 +2,19 @@ $:.push File.expand_path("../lib", __FILE__)
 
 Gem::Specification.new do |s|
   s.name        = "foreman-export-systemd_user"
-  s.version     = "0.1.2"
+  s.version     = "0.2.1"
   s.authors     = ["Micah Geisel"]
   s.email       = ["micah@botandrose.com"]
   s.homepage    = "http://github.com/botandrose/foreman-export-systemd_user"
-  s.summary     = "Upstart user-level export scripts for systemd on Ubuntu 16.04+"
-  s.description = "Upstart user-level export scripts for systemd on Ubuntu 16.04+"
+  s.summary     = "Foreman export scripts for user-level systemd"
+  s.description = "Foreman export scripts for user-level systemd"
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_runtime_dependency "foreman"
+  s.add_runtime_dependency "foreman", ">= 0.90.0"
+
+  s.add_development_dependency "rspec"
 end

data/lib/foreman/export/systemd_user.rb

@@ -1,17 +1,13 @@
 require "erb"
 require "foreman/export"
 
-File.instance_eval { def exists?(p); exist?(p); end } # restore old method removed in Ruby 3.2, because foreman 0.87.2 uses it, and appears abandoned, and I don't want to maintain a fork.
-
 class Foreman::Export::SystemdUser < Foreman::Export::Base
-  def initialize location, engine, options={}
-    super
-    # what a pain in the ass
-    # template is obviously not intended to be overriden
-    unless @options.has_key?(:template)
-      template = File.expand_path("../../../../data/export/systemd_user", __FILE__)
-      @options = { template: template }.merge(@options).freeze
-    end
+  TEMPLATE_DIR = File.expand_path("../../../../data/export/systemd_user", __FILE__)
+
+  def initialize(location, engine, options = {})
+    options = options.dup
+    options[:template] ||= TEMPLATE_DIR
+    super(location, engine, options)
   end
 
   def app
@@ -24,7 +20,15 @@ class Foreman::Export::SystemdUser < Foreman::Export::Base
 
   def export
     super
+    clean_old_units
+    write_units
+    install_include_dir
+    configure_systemd
+  end
+
+  private
 
+  def clean_old_units
     Dir["#{location}/#{app}*.target"]
       .concat(Dir["#{location}/#{app}*.service"])
       .concat(Dir["#{location}/#{app}*.target.wants/#{app}*.service"])
@@ -35,7 +39,9 @@ class Foreman::Export::SystemdUser < Foreman::Export::Base
     Dir["#{location}/#{app}*.target.wants"].each do |file|
       clean_dir file
     end
+  end
 
+  def write_units
     process_master_names = []
 
     engine.each_process do |name, process|
@@ -55,17 +61,41 @@ class Foreman::Export::SystemdUser < Foreman::Export::Base
     end
 
     write_template "systemd_user/master.target.erb", "#{app}.target", binding
-
-    run_command "test -f /var/lib/systemd/linger/$USER || loginctl enable-linger"
-    run_command "systemctl --user enable #{app}.target"
-    run_command "systemctl --user restart #{app}.target"
   end
 
-  private
-
   def run_command command
     puts command
     raise unless system(command)
   end
+
+  def include_dir
+    dir = options[:include_dir]
+    return unless dir
+
+    raise "include_dir '#{dir}' is not a directory" unless File.directory?(dir)
+    dir
+  end
+
+  def install_include_dir
+    if include_dir
+      run_command "cp -r #{include_dir}/. #{location}/"
+    end
+  end
+
+  def configure_systemd
+    run_command "systemctl --user daemon-reload"
+    run_command "test -f /var/lib/systemd/linger/$USER || loginctl enable-linger"
+    run_command "systemctl --user enable #{app}.target"
+    enable_timers
+  end
+
+  def enable_timers
+    if include_dir
+      Dir.glob("#{include_dir}/*.timer").each do |timer|
+        timer_name = File.basename(timer)
+        run_command "systemctl --user enable --now #{timer_name}"
+      end
+    end
+  end
 end
 

data/spec/Dockerfile.systemd

@@ -0,0 +1,38 @@
+FROM ubuntu:22.04
+
+ENV DEBIAN_FRONTEND=noninteractive
+
+RUN apt-get update && apt-get install -y \
+    systemd \
+    systemd-sysv \
+    dbus \
+    dbus-user-session \
+    ruby \
+    ruby-bundler \
+    git \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create test user
+RUN useradd -m -s /bin/bash testuser \
+    && mkdir -p /home/testuser/.config/systemd/user \
+    && chown -R testuser:testuser /home/testuser
+
+# Enable linger for testuser so user services start at boot
+RUN mkdir -p /var/lib/systemd/linger \
+    && touch /var/lib/systemd/linger/testuser
+
+# Remove unnecessary systemd services that won't work in container
+RUN rm -f /lib/systemd/system/multi-user.target.wants/* \
+    /etc/systemd/system/*.wants/* \
+    /lib/systemd/system/local-fs.target.wants/* \
+    /lib/systemd/system/sockets.target.wants/*udev* \
+    /lib/systemd/system/sockets.target.wants/*initctl* \
+    /lib/systemd/system/sysinit.target.wants/systemd-tmpfiles-setup* \
+    /lib/systemd/system/systemd-update-utmp*
+
+VOLUME ["/sys/fs/cgroup"]
+
+STOPSIGNAL SIGRTMIN+3
+
+CMD ["/sbin/init"]

data/spec/foreman/export/systemd_user_spec.rb

@@ -0,0 +1,160 @@
+require "spec_helper"
+
+RSpec.describe "foreman export systemd-user" do
+  let(:container) { SystemdContainer }
+  let(:app_name) { "testapp" }
+  let(:systemd_dir) { container.user_systemd_dir }
+
+  before(:all) do
+    # Copy gem files to container and install
+    @gem_path = SystemdContainer.copy_gem_to_container
+    SystemdContainer.exec("bash", "-c", "cd #{@gem_path} && bundle install --quiet 2>&1")
+
+    # Set up a minimal Procfile in the test user's app directory
+    SystemdContainer.exec_as_user("mkdir -p /home/testuser/app")
+    SystemdContainer.exec_as_user("echo 'web: ruby -run -e httpd . -p $PORT' > /home/testuser/app/Procfile")
+
+    # Create a Gemfile in the app dir that references our gem
+    SystemdContainer.exec_as_user("cat > /home/testuser/app/Gemfile << EOF
+source 'https://rubygems.org'
+gem 'foreman-export-systemd_user', path: '#{@gem_path}'
+EOF")
+    SystemdContainer.exec_as_user("cd /home/testuser/app && bundle config set --local path 'vendor/bundle' && bundle install --quiet 2>&1")
+  end
+
+  describe "basic export" do
+    before(:all) do
+      stdout, stderr, status = SystemdContainer.exec_as_user(
+        "cd /home/testuser/app && bundle exec foreman export systemd-user --app testapp 2>&1"
+      )
+      @export_output = stdout
+      @export_status = status
+    end
+
+    it "succeeds" do
+      expect(@export_status).to be_success
+    end
+
+    it "creates the master target file" do
+      stdout, _, _ = container.exec_as_user("cat #{systemd_dir}/testapp.target")
+      expect(stdout).to include("[Unit]")
+      expect(stdout).to include("testapp-web.target")
+    end
+
+    it "creates the process target file" do
+      stdout, _, _ = container.exec_as_user("cat #{systemd_dir}/testapp-web.target")
+      expect(stdout).to include("[Unit]")
+    end
+
+    it "creates the process service template" do
+      stdout, _, _ = container.exec_as_user("cat #{systemd_dir}/testapp-web@.service")
+      expect(stdout).to include("[Service]")
+      expect(stdout).to include("ExecStart=")
+    end
+
+    it "creates the target.wants directory with symlinks" do
+      stdout, _, _ = container.exec_as_user("ls -la #{systemd_dir}/testapp-web.target.wants/")
+      expect(stdout).to include("testapp-web@")
+      expect(stdout).to include("-> ../testapp-web@.service")
+    end
+
+    it "runs daemon-reload" do
+      expect(@export_output).to include("systemctl --user daemon-reload")
+    end
+
+    it "enables linger" do
+      expect(@export_output).to include("loginctl enable-linger")
+    end
+
+    it "enables the target" do
+      expect(@export_output).to include("systemctl --user enable testapp.target")
+    end
+
+    it "the target can be started" do
+      stdout, _, _ = container.exec_as_user("systemctl --user start testapp.target && systemctl --user is-active testapp.target")
+      expect(stdout.strip).to eq("active")
+    end
+  end
+
+  describe "with --include-dir" do
+    before(:all) do
+      # Create include-dir with drop-in and timer
+      SystemdContainer.exec_as_user("mkdir -p /home/testuser/app/Procfile.systemd/testapp-web@.service.d")
+      SystemdContainer.exec_as_user("echo '[Service]\nEnvironment=EXTRA=value' > /home/testuser/app/Procfile.systemd/testapp-web@.service.d/override.conf")
+
+      # Create a simple timer
+      SystemdContainer.exec_as_user("cat > /home/testuser/app/Procfile.systemd/testapp-cleanup.timer << 'EOF'
+[Unit]
+Description=Cleanup timer
+
+[Timer]
+OnCalendar=daily
+
+[Install]
+WantedBy=timers.target
+EOF")
+
+      SystemdContainer.exec_as_user("cat > /home/testuser/app/Procfile.systemd/testapp-cleanup.service << 'EOF'
+[Unit]
+Description=Cleanup service
+
+[Service]
+Type=oneshot
+ExecStart=/bin/true
+EOF")
+
+      # Stop any existing target first
+      SystemdContainer.exec_as_user("systemctl --user stop testapp.target 2>/dev/null || true")
+
+      # Run export with --include-dir
+      stdout, stderr, status = SystemdContainer.exec_as_user(
+        "cd /home/testuser/app && bundle exec foreman export systemd-user --app testapp --include-dir Procfile.systemd 2>&1"
+      )
+      @export_output = stdout
+      @export_status = status
+    end
+
+    it "succeeds" do
+      expect(@export_status).to be_success
+    end
+
+    it "copies the drop-in directory" do
+      stdout, _, _ = container.exec_as_user("cat #{systemd_dir}/testapp-web@.service.d/override.conf")
+      expect(stdout).to include("EXTRA=value")
+    end
+
+    it "copies the timer file" do
+      stdout, _, _ = container.exec_as_user("cat #{systemd_dir}/testapp-cleanup.timer")
+      expect(stdout).to include("OnCalendar=daily")
+    end
+
+    it "copies the service file" do
+      stdout, _, _ = container.exec_as_user("cat #{systemd_dir}/testapp-cleanup.service")
+      expect(stdout).to include("ExecStart=/bin/true")
+    end
+
+    it "enables the timer with --now" do
+      expect(@export_output).to include("systemctl --user enable --now testapp-cleanup.timer")
+    end
+
+    it "the timer is active" do
+      stdout, _, _ = container.exec_as_user("systemctl --user is-active testapp-cleanup.timer")
+      expect(stdout.strip).to eq("active")
+    end
+
+    it "the drop-in is applied" do
+      stdout, _, _ = container.exec_as_user("systemctl --user show testapp-web@5000.service -p Environment")
+      expect(stdout).to include("EXTRA=value")
+    end
+  end
+
+  describe "error handling" do
+    it "raises error when include-dir is not a directory" do
+      stdout, _, status = container.exec_as_user(
+        "cd /home/testuser/app && bundle exec foreman export systemd-user --app testapp --include-dir /nonexistent 2>&1"
+      )
+      expect(status).not_to be_success
+      expect(stdout).to include("not a directory")
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,102 @@
+require "open3"
+require "fileutils"
+require "tmpdir"
+
+module SystemdContainer
+  DOCKERFILE_PATH = File.expand_path("Dockerfile.systemd", __dir__)
+  IMAGE_NAME = "foreman-export-systemd-user-test"
+  CONTAINER_NAME = "foreman-export-systemd-user-test-container"
+  TEST_USER = "testuser"
+
+  class << self
+    def start
+      build_image
+      stop
+
+      cmd = [
+        "podman", "run", "-d",
+        "--name", CONTAINER_NAME,
+        "--privileged",
+        "-v", "/sys/fs/cgroup:/sys/fs/cgroup:rw",
+        IMAGE_NAME
+      ]
+      run_command(cmd)
+      wait_for_systemd
+    end
+
+    def stop
+      system("podman", "stop", CONTAINER_NAME, out: File::NULL, err: File::NULL)
+      system("podman", "rm", CONTAINER_NAME, out: File::NULL, err: File::NULL)
+    end
+
+    def exec(*command)
+      cmd = ["podman", "exec", CONTAINER_NAME] + command.flatten
+      stdout, stderr, status = Open3.capture3(*cmd)
+      [stdout, stderr, status]
+    end
+
+    def exec_as_user(command)
+      exec("su", "-", TEST_USER, "-c", command)
+    end
+
+    def user_systemd_dir
+      "/home/#{TEST_USER}/.config/systemd/user"
+    end
+
+    def copy_to_container(src, dest)
+      run_command(["podman", "cp", src, "#{CONTAINER_NAME}:#{dest}"])
+    end
+
+    def copy_gem_to_container(dest = "/tmp/gem")
+      gem_root = File.expand_path("../..", __FILE__)
+
+      # Copy entire gem directory (including .git for gemspec)
+      copy_to_container(gem_root, dest)
+
+      # Remove Gemfile.lock to avoid bundler version mismatch
+      exec("rm", "-f", "#{dest}/Gemfile.lock")
+
+      # Fix permissions so test user can read the gem files
+      exec("chmod", "-R", "a+rX", dest)
+
+      # Fix git safe.directory for root and test user
+      exec("git", "config", "--global", "--add", "safe.directory", dest)
+      exec_as_user("git config --global --add safe.directory #{dest}")
+
+      dest
+    end
+
+    private
+
+    def run_command(cmd)
+      stdout, stderr, status = Open3.capture3(*cmd)
+      raise "Command failed: #{cmd.join(' ')}\n#{stderr}" unless status.success?
+      stdout
+    end
+
+    def build_image
+      run_command(["podman", "build", "-t", IMAGE_NAME, "-f", DOCKERFILE_PATH, File.dirname(DOCKERFILE_PATH)])
+    end
+
+    def wait_for_systemd(timeout: 30)
+      deadline = Time.now + timeout
+      loop do
+        stdout, _, status = exec("systemctl", "is-system-running")
+        state = stdout.strip
+        break if %w[running degraded].include?(state)
+        raise "Timed out waiting for systemd" if Time.now > deadline
+        sleep 0.5
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    SystemdContainer.start
+  end
+
+  config.after(:suite) do
+    SystemdContainer.stop
+  end
+end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: foreman-export-systemd_user
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.1
 platform: ruby
 authors:
 - Micah Geisel
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-12-29 00:00:00.000000000 Z
+date: 2026-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: foreman
@@ -16,36 +15,57 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.90.0
   type: :runtime
   prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.90.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Upstart user-level export scripts for systemd on Ubuntu 16.04+
+description: Foreman export scripts for user-level systemd
 email:
 - micah@botandrose.com
-executables: []
+executables:
+- foreman
+- setup
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
 - ".gitignore"
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
+- bin/foreman
+- bin/setup
 - data/export/systemd_user/master.target.erb
 - data/export/systemd_user/process.service.erb
 - data/export/systemd_user/process_master.target.erb
 - foreman-export-systemd_user.gemspec
 - lib/foreman-export-systemd_user.rb
 - lib/foreman/export/systemd_user.rb
+- spec/Dockerfile.systemd
+- spec/foreman/export/systemd_user_spec.rb
+- spec/spec_helper.rb
 homepage: http://github.com/botandrose/foreman-export-systemd_user
 licenses: []
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -60,8 +80,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.32
-signing_key: 
+rubygems_version: 3.6.2
 specification_version: 4
-summary: Upstart user-level export scripts for systemd on Ubuntu 16.04+
+summary: Foreman export scripts for user-level systemd
 test_files: []