wait for user when using linger

Author: bwitt

lib/puppet/provider/loginctl_user/ruby.rb

@@ -33,8 +33,48 @@ def linger=(value)
     case value
     when :enabled
       loginctl('enable-linger', resource[:name])
+      # Wait for systemd --user instance to be ready after enabling linger
+      wait_for_user_systemd_ready(resource[:name])
     when :disabled
       loginctl('disable-linger', resource[:name])
     end
   end
+
+  def wait_for_user_systemd_ready(username, timeout = 10)
+    # Try to connect to the user's systemd instance using loginctl show-user
+    # which queries the user's systemd instance state
+    start_time = Time.now
+    loop do
+      begin
+        # Try to get user runtime directory which indicates systemd --user is running
+        output = loginctl('show-user', username, '-p', 'RuntimePath')
+        runtime_path = output.strip.split('=')[1]
+
+        # Check if the systemd --user socket exists and is accessible
+        if runtime_path && !runtime_path.empty?
+          socket_path = "#{runtime_path}/systemd/private"
+          if File.exist?(socket_path)
+            # try to actually communicate with systemd --user
+            # by checking if the user's systemd is in running state
+            state_output = loginctl('show-user', username, '-p', 'State')
+            state = state_output.strip.split('=')[1]
+            if %w[active lingering].include?(state)
+              Puppet.debug("systemd --user for #{username} is ready")
+              break
+            end
+          end
+        end
+      rescue Puppet::ExecutionFailure => e
+        # loginctl command failed, systemd --user might not be ready yet
+        Puppet.debug("Waiting for systemd --user for #{username}: #{e.message}")
+      end
+
+      if Time.now - start_time > timeout
+        Puppet.warning("Timeout waiting for systemd --user instance for user #{username} to become ready, continuing anyway")
+        break
+      end
+
+      sleep 1
+    end
+  end
 end

spec/acceptance/user_service_spec.rb

@@ -22,13 +22,6 @@
           linger  => enabled,
         }
 
-        # https://github.com/voxpupuli/puppet-systemd/issues/578
-        exec{'/usr/bin/sleep 10 && touch /tmp/sleep-only-once':
-          creates   => '/tmp/sleep-only-once',
-          require   => Loginctl_user['higgs'],
-          before    => File['/home/higgs/.config'],
-        }
-
         # Assumes home directory was created as /home/higgs
         file{['/home/higgs/.config', '/home/higgs/.config/systemd','/home/higgs/.config/systemd/user']:
           ensure => directory,

spec/unit/puppet/provider/loginctl_user/ruby_spec.rb

@@ -27,13 +27,92 @@
     end
   end
 
-  it 'enables linger' do
-    resource = Puppet::Type.type(:loginctl_user).new(common_params)
-    expect(provider_class).to receive(:loginctl).with('enable-linger', 'foo')
-    resource.provider.linger = :enabled
+  context 'when enabling linger' do
+    let(:resource) { Puppet::Type.type(:loginctl_user).new(common_params) }
+    let(:provider) { resource.provider }
+
+    it 'enables linger and waits for systemd --user to be ready' do
+      expect(provider).to receive(:loginctl).with('enable-linger', 'foo')
+      expect(provider).to receive(:loginctl).with('show-user', 'foo', '-p', 'RuntimePath').
+        and_return("RuntimePath=/run/user/1000\n")
+      expect(File).to receive(:exist?).with('/run/user/1000/systemd/private').and_return(true)
+      expect(provider).to receive(:loginctl).with('show-user', 'foo', '-p', 'State').
+        and_return("State=active\n")
+      expect(Puppet).to receive(:debug).with('systemd --user for foo is ready')
+
+      provider.linger = :enabled
+    end
+
+    it 'waits and retries if systemd --user is not immediately ready' do
+      expect(provider).to receive(:loginctl).with('enable-linger', 'foo')
+
+      # First attempt: RuntimePath not ready
+      expect(provider).to receive(:loginctl).with('show-user', 'foo', '-p', 'RuntimePath').
+        and_return("RuntimePath=\n")
+
+      # Second attempt: Socket doesn't exist yet
+      expect(provider).to receive(:loginctl).with('show-user', 'foo', '-p', 'RuntimePath').
+        and_return("RuntimePath=/run/user/1000\n")
+      expect(File).to receive(:exist?).with('/run/user/1000/systemd/private').and_return(false)
+
+      # Third attempt: State not active yet
+      expect(provider).to receive(:loginctl).with('show-user', 'foo', '-p', 'RuntimePath').
+        and_return("RuntimePath=/run/user/1000\n")
+      expect(File).to receive(:exist?).with('/run/user/1000/systemd/private').and_return(true)
+      expect(provider).to receive(:loginctl).with('show-user', 'foo', '-p', 'State').
+        and_return("State=opening\n")
+
+      # Fourth attempt: Success with lingering state
+      expect(provider).to receive(:loginctl).with('show-user', 'foo', '-p', 'RuntimePath').
+        and_return("RuntimePath=/run/user/1000\n")
+      expect(File).to receive(:exist?).with('/run/user/1000/systemd/private').and_return(true)
+      expect(provider).to receive(:loginctl).with('show-user', 'foo', '-p', 'State').
+        and_return("State=lingering\n")
+      expect(Puppet).to receive(:debug).with('systemd --user for foo is ready')
+
+      allow(provider).to receive(:sleep)
+
+      provider.linger = :enabled
+    end
+
+    it 'handles loginctl failures gracefully while waiting' do
+      expect(provider).to receive(:loginctl).with('enable-linger', 'foo')
+
+      # First attempt: loginctl fails
+      expect(provider).to receive(:loginctl).with('show-user', 'foo', '-p', 'RuntimePath').
+        and_raise(Puppet::ExecutionFailure, 'Failed to get user properties')
+      expect(Puppet).to receive(:debug).with(%r{Waiting for systemd --user for foo})
+
+      # Second attempt: Success
+      expect(provider).to receive(:loginctl).with('show-user', 'foo', '-p', 'RuntimePath').
+        and_return("RuntimePath=/run/user/1000\n")
+      expect(File).to receive(:exist?).with('/run/user/1000/systemd/private').and_return(true)
+      expect(provider).to receive(:loginctl).with('show-user', 'foo', '-p', 'State').
+        and_return("State=active\n")
+      expect(Puppet).to receive(:debug).with('systemd --user for foo is ready')
+
+      allow(provider).to receive(:sleep)
+
+      provider.linger = :enabled
+    end
+
+    it 'logs a warning and continues if timeout is exceeded' do
+      expect(provider).to receive(:loginctl).with('enable-linger', 'foo')
+
+      # Mock Time to simulate timeout
+      start_time = Time.now
+      allow(Time).to receive(:now).and_return(start_time, start_time + 11)
+
+      expect(provider).to receive(:loginctl).with('show-user', 'foo', '-p', 'RuntimePath').
+        and_return("RuntimePath=\n")
+
+      expect(Puppet).to receive(:warning).with(%r{Timeout waiting for systemd --user instance for user foo to become ready, continuing anyway})
+
+      provider.linger = :enabled
+    end
   end
 
-  it 'disables linger' do
+  it 'disables linger without waiting' do
     resource = Puppet::Type.type(:loginctl_user).new(common_params)
     expect(provider_class).to receive(:loginctl).with('disable-linger', 'foo')
     resource.provider.linger = :disabled