*
 * TODO - this type could be simplified, as there is no longer any need to send/receive messages to/from multiple connections
 */
public class MessageHub implements AsyncStoppable {
    private enum State {Running, Stopping, Stopped}

    private static final Discard DISCARD = new Discard();
    private final ManagedExecutor workers;
    private final String displayName;
    private final Action<? super Throwable> errorHandler;

    }

    public ServiceRegistry getServices() {
        return services;
    }

    @Override
    public void close() {
        // Force the user home services to be stopped first, because the dependencies between the user home services and the global services are not preserved currently
        CompositeStoppable.stoppable(services.get(GradleUserHomeScopeServiceRegistry.class), services).stop();
    }

     */
    @Override
    void stop();

    /**
     * Indicate that the execution containing this {@code ObjectConnection} has been prematurely stopped.
     */
    void abort();

    /**
     * Add a callback upon unrecoverable errors, e.g. broken connection. Should not throw any exceptions because
     * this is the last line of defense.

					eventMsg = fmt.Sprintf("%s, victim process: %s, pid: %d", eventMsg, event.ProcessName, event.Pid)
				}
				ow.recorder.Eventf(ref, v1.EventTypeWarning, systemOOMEvent, eventMsg)
			}
		}
		klog.ErrorS(nil, "Unexpectedly stopped receiving OOM notifications")
	}()
	return nil

	// Meant to be run inside a goroutine
	// Waits for and reacts to changes in whatever type the controller
	// is concerned with.
	//
	// Returns an error always non-nil explaining why the worker stopped
	Run(ctx context.Context) error

	// Retrieves the informer used to back this controller
	Informer() Informer[T]

	// Returns true if the informer cache has synced, and all the objects from

            instant.actionCompleted
        }

        when:
        async {
            worker.runLater(action)
            worker.stop()
            instant.stopped
        }

        then:
        instant.stopped > instant.actionCompleted
    }

    def "can use operation to test that a method blocks until action is complete"() {
        Worker worker = new Worker(executor)

        given:

		} else {
			r.readImport()
		}
	}

	info.header = r.buf

	// If we stopped successfully before EOF, we read a byte that told us we were done.
	// Return all but that last byte, which would cause a syntax error if we let it through.
	if r.err == nil && !r.eof {
		info.header = r.buf[:len(r.buf)-1]
	}

	// If we stopped for a syntax error, consume the whole file so that

        } catch (final ContainerNotAvailableException e) {
            if (logger.isDebugEnabled()) {
                logger.debug("SuggestCreator is stopped.", e);
            } else if (logger.isInfoEnabled()) {
                logger.info("SuggestCreator is stopped.");
            }
            exitCode = Constants.EXIT_FAIL;
        } catch (final Throwable t) {

  # Wait (if necessary) for service to stop.
  $timeout = 10
  $stopped = (Get-service $service).Status -eq 'Stopped'
  for ($i = 0; $i -lt $timeout -and !($stopped); $i++) {
      Start-Sleep 1
      $stopped = (Get-service $service).Status -eq 'Stopped'
  }

  if ((Get-service $service).Status -ne 'Stopped') {
    # Force kill the processes.

                    return event2.getStatus().compareTo(event1.getStatus());
                }
                return 0;
            }
        });

        // User likely doesn't care about daemons that stopped a long time ago
        for (DaemonStopEvent event : sortedEvents) {
            Long pid = event.getPid();
            if (event.occurredInLastHours(RECENTLY) && !uniqueStoppedPids.contains(pid)) {