handler.controller = startNodeResourcesController(context.TODO(), kubeClient, getNode)

	return handler
}

// RegisterPlugin is called when a plugin can be registered.
func (h *RegistrationHandler) RegisterPlugin(pluginName string, endpoint string, versions []string, pluginClientTimeout *time.Duration) error {
	klog.InfoS("Register new DRA plugin", "name", pluginName, "endpoint", endpoint)

func (h *HumanReadableGenerator) With(fns ...func(PrintHandler)) *HumanReadableGenerator {
	for _, fn := range fns {
		fn(h)
	}
	return h
}

// GenerateTable returns a table for the provided object, using the printer registered for that type. It returns
// a table that includes all of the information requested by options, but will not remove rows or columns. The
// caller is responsible for applying rules related to filtering rows or columns.

		for cid, c := range clusters {
			outCluster := *c
			out[secret][cid] = &outCluster
		}
	}
	return out
}

// GetExistingClustersFor return existing clusters registered for the given secret
func (c *ClusterStore) GetExistingClustersFor(secretKey string) []*Cluster {
	c.RLock()
	defer c.RUnlock()
	out := make([]*Cluster, 0, len(c.remoteClusters[secretKey]))

        1 * softwareTypeRegistry.register(SoftwareTypePlugin.class, null)

        and:
        1 * delegate.applyImperative(null, plugin)
    }

    def "throws exception when plugins are registered that do not expose software types"() {
        when:
        pluginTarget.applyImperative(null, plugin)

        then: // setup property metadata
        2 * inspectionScheme.getMetadataStore() >> metadataStore

	// queue contains workloadEntry that need to be unregistered
	queue controllers.Queue
	// cleanupLimit rate limit's auto registered WorkloadEntry cleanup calls to k8s
	cleanupLimit *rate.Limiter
	// cleanupQueue delays the cleanup of auto registered WorkloadEntries to allow for grace period
	cleanupQueue queue.Delayed

	adsConnections        *adsConnections
	lateRegistrationQueue controllers.Queue

    return "Decompose TF ops with the registered composition library.";
  }

  void runOnOperation() override;

 private:
  // Apply canonicalization, mainly constant folding, on the function.
  void ApplyCanonicalization();

  // Rewrite unregistered TF ops to TFR func call ops. Return failure if all the
  // ops are registered or the compose function doesn't exist.

				},
				{Resource: framework.Node, ActionType: framework.UpdateNodeTaint}: {
					{PluginName: fakeNode, QueueingHintFn: defaultQueueingHintFn}, // When Node/Add is registered, Node/UpdateNodeTaint is automatically registered.
				},
			},
		},
		{
			name:                "node and pod plugin (featuregate is disabled)",
			plugins:             []framework.Plugin{&fakeNodePlugin{}, &fakePodPlugin{}},

import java.util.List;

@ServiceScope(Scope.Global.class)
public interface OperationResultPostProcessorFactory {
    /**
     * Creates the post processors relevant for the given subscriptions. The processors are also registered as listeners.
     */
    List<OperationResultPostProcessor> createProcessors(BuildEventSubscriptions subscriptions, BuildEventConsumer consumer);

| [Bouncy Castle]  | ✅      |              | [Bouncy Castle] | [Tracking bug.][bug5698]                                     |
| [Conscrypt]      | ✅      | ✅           | [BoringSSL]     | Activated if Conscrypt is first registered provider.         |
| [OpenJSSE]       |         | ✅           | [OpenJDK]       | OpenJDK backport.                                            |

As part of the application object creation, a *path operation* for `/openapi.json` (or for whatever you set your `openapi_url`) is registered.

It just returns a JSON response with the result of the application's `.openapi()` method.

By default, what the method `.openapi()` does is check the property `.openapi_schema` to see if it has contents and return them.