)

// Union returns an audit Backend which logs events to a set of backends. The returned
// Sink implementation blocks in turn for each call to ProcessEvents.
func Union(backends ...Backend) Backend {
	if len(backends) == 1 {
		return backends[0]
	}
	return union{backends}
}

type union struct {
	backends []Backend
}

func (u union) ProcessEvents(events ...*auditinternal.Event) bool {

	MaxBatchSize int64
}

type backend struct {
	// The delegate backend that actually exports events.
	delegateBackend audit.Backend

	// Configuration used for truncation.
	c Config

	// Encoder used to calculate audit event sizes.
	e runtime.Encoder
}

var _ audit.Backend = &backend{}

// NewBackend returns a new truncating backend, using configuration passed in the parameters.

      - path: /path
        backend:
          service:
            name: service1
            port:
              number: 4200
        # Subpath without trailing /
      - path: /sub/path
        backend:
          service:
            name: service1
            port:
              number: 4201
      # With a trailing /
      - path: /sub/path/
        backend:
          service:

				return authorizer.AuthorizerFunc(func(_ context.Context, attributes authorizer.Attributes) (authorizer.Decision, string, error) {
					if misses >= len(tc.backend) {
						t.Fatalf("got more than expected %d backend invocations", len(tc.backend))
					}
					result := tc.backend[misses]
					misses++
					return result.decision, result.reason, result.error
				})
			}())

			for i, invocation := range tc.calls {

        pathType: Exact
        backend:
          service:
            name: productpage
            port:
              number: 9080
      - path: /static/
        pathType: Prefix
        backend:
          service:
            name: productpage
            port:
              number: 9080
      - path: /login
        pathType: Exact
        backend:
          service:
            name: productpage

	}{
		"service-port-number": {
			external: v1beta1.IngressSpec{
				Backend: &v1beta1.IngressBackend{
					ServiceName: "test-backend",
					ServicePort: intstr.FromInt32(8080),
				},
			},
			internal: networking.IngressSpec{
				DefaultBackend: &networking.IngressBackend{
					Service: &networking.IngressServiceBackend{
						Name: "test-backend",
						Port: networking.ServiceBackendPort{
							Name:   "",

	// This WaitGroup is used to wait for all sending routines to finish before shutting down audit backend.
	wg sync.WaitGroup

	// Limits the number of batches sent to the delegate backend per second.
	throttle flowcontrol.RateLimiter
}

var _ audit.Backend = &bufferedBackend{}

// NewBackend returns a buffered audit backend that wraps delegate backend.

type DestroyFunc func()

// Create creates a storage backend based on given config.
func Create(c storagebackend.ConfigForResource, newFunc, newListFunc func() runtime.Object, resourcePrefix string) (storage.Interface, DestroyFunc, error) {
	switch c.Type {
	case storagebackend.StorageTypeETCD2:
		return nil, nil, fmt.Errorf("%s is no longer a supported storage backend", c.Type)

	}

	w.ShouldRetry = retryOnError
	return w, nil
}

type backend struct {
	w    *webhook.GenericWebhook
	name string
}

// NewDynamicBackend returns an audit backend configured from a REST client that
// sends events over HTTP to an external service.
func NewDynamicBackend(rc *rest.RESTClient, retryBackoff wait.Backoff) audit.Backend {
	return &backend{
		w: &webhook.GenericWebhook{
			RestClient:   rc,

        isDaemon = true
        uncaughtExceptionHandler = loggingUncaughtExceptionHandler
      }
    }

  private val backend = TaskRunner.RealBackend(threadFactory)
  private val taskRunner = TaskRunner(backend)
  private val queue = taskRunner.newQueue()

  @AfterEach fun tearDown() {
    backend.shutdown()
  }

  @Test fun test() {
    val t1 = System.nanoTime() / 1e6