handle example

        $this->catchExceptions = $catchExceptions;
    }

    /** * @param Request $request * * @return Response */
    protected function doRequest(object $request)
    {
        $response = $this->kernel->handle($request, HttpKernelInterface::MAIN_REQUEST, $this->catchExceptions);

        if ($this->kernel instanceof TerminableInterface) {
            $this->kernel->terminate($request, $response);
        }

        return $response;
    }

    /** * @param Request $request * * @return string */

  public function handle(Request $request, $type = self::MAIN_REQUEST, $catch = TRUE): Response {
    $request->attributes->set('_hello', 'world');
    if ($request->attributes->has('_optional_argument')) {
      $request->attributes->set('_previous_optional_argument', $request->attributes->get('_optional_argument'));
    }
    elseif (isset($this->optionalArgument)) {
      $request->attributes->set('_optional_argument', $this->optionalArgument);
    }

    return $this->kernel->handle($request, $type, $catch);
  }

}

public function __construct(HttpKernelInterface $http_kernel, Settings $settings) {
    $this->httpKernel = $http_kernel;
    $this->settings = $settings;
  }

  /** * {@inheritdoc} */
  public function handle(Request $request, $type = self::MAIN_REQUEST, $catch = TRUE): Response {
    // Initialize proxy settings.     static::setSettingsOnRequest($request, $this->settings);
    return $this->httpKernel->handle($request, $type, $catch);
  }

  /** * Sets reverse proxy settings on Request object. * * @param \Symfony\Component\HttpFoundation\Request $request * A Request instance. * @param \Drupal\Core\Site\Settings $settings * The site settings. */
  public static function setSettingsOnRequest(Request $request, Settings $settings) {
    

    /** * @internal */
    public function __invoke(EntityIndexingMessage|IterateEntityIndexerMessage $message): void
    {
        if ($message instanceof EntityIndexingMessage) {
            $indexer = $this->getIndexer($message->getIndexer());

            if ($indexer) {
                $indexer->handle($message);
            }

            return;
        }

        if ($message instanceof IterateEntityIndexerMessage) {
            $next = $this->iterateIndexer($message->getIndexer(), $message->getOffset(), true, $message->getSkip());

            if (!$next) {
                return;
            }

            

    public function dummyMethodForSomeBus()
    {
    }
}

class UselessMiddleware implements MiddlewareInterface
{
    public function handle(Envelope $message, StackInterface $stack): Envelope
    {
        return $stack->next()->handle($message, $stack);
    }
}

            ],
            ['ids' => ArrayParameterType::STRING]
        );

        $categories = $this->categoryRepository->search(new Criteria([$categoryA, $categoryB, $categoryC, $categoryD]), $this->context);
        foreach ($categories as $category) {
            static::assertEquals(0, $category->getLevel());
            static::assertNull($category->getPath());
        }

        $this->categoryIndexer->handle(
            new EntityIndexingMessage([$categoryA, $categoryB, $categoryC, $categoryD])
        );

        $categories = $this->categoryRepository->search(new Criteria([$categoryA, $categoryB, $categoryC, $categoryD]), $this->context);

        static::assertNull($categories->get($categoryA)->getPath());
        static::assertEquals("|{$categoryA}|", $categories->get($categoryB)->getPath());
        static::assertEquals("|{$categoryA}|", $categories->get($categoryC)->getPath());
        static::assertEquals("|{$categoryA}|{$categoryC}|", $categories->get($categoryD)->getPath());

        static::assertEquals(1, $categories->get($categoryA)->getLevel());
        

// Disable garbage collection during test runs. Under certain circumstances the // update path will create so many objects that garbage collection causes // segmentation faults. if (drupal_valid_test_ua()) {
  gc_collect_cycles();
  gc_disable();
}

$kernel = new UpdateKernel('prod', $autoloader, FALSE);
$request = Request::createFromGlobals();

$response = $kernel->handle($request);
$response->send();

$kernel->terminate($request, $response);

/** * Wraps all handlers in a single doctrine transaction. * * @author Tobias Nyholm <tobias.nyholm@gmail.com> */
class DoctrineTransactionMiddleware extends AbstractDoctrineMiddleware
{
    protected function handleForManager(EntityManagerInterface $entityManager, Envelope $envelope, StackInterface $stack): Envelope
    {
        $entityManager->getConnection()->beginTransaction();
        try {
            $envelope = $stack->next()->handle($envelope, $stack);
            $entityManager->flush();
            $entityManager->getConnection()->commit();

            return $envelope;
        } catch (\Throwable $exception) {
            $entityManager->getConnection()->rollBack();

            if ($exception instanceof HandlerFailedException) {
                // Remove all HandledStamp from the envelope so the retry will execute all handlers again.                 // When a handler fails, the queries of allegedly successful previous handlers just got rolled back.                 throw new HandlerFailedException($exception->getEnvelope()->withoutAll(HandledStamp::class), $exception->getNestedExceptions());
            }

public function testWritingAndFormatting()
    {
        $host = 'tcp://127.0.0.1:9999';
        $handler = new ServerLogHandler($host, Logger::INFO, false);
        $handler->pushProcessor(new ProcessIdProcessor());

        $infoRecord = RecordFactory::create(Logger::INFO, 'My info message', 'app', datetime: new \DateTimeImmutable('2013-05-29 16:21:54'));

        $socket = stream_socket_server($host, $errno, $errstr);
        $this->assertIsResource($socket, sprintf('Server start failed on "%s": %s %s.', $host, $errstr, $errno));

        $this->assertTrue($handler->handle($infoRecord), 'The handler finished handling the log as bubble is false.');

        $sockets = [(int) $socket => $socket];
        $write = [];

        for ($i = 0; $i < 10; ++$i) {
            $read = $sockets;
            stream_select($read, $write, $write, null);

            foreach ($read as $stream) {
                if ($socket === $stream) {
                    $stream = stream_socket_accept($socket);
                    

return $message;
        });

        $indexer = new CustomerIndexer(
            $this->createMock(IteratorFactory::class),
            $this->createMock(EntityRepository::class),
            $this->createMock(ManyToManyIdFieldUpdater::class),
            $this->createMock(CustomerNewsletterSalesChannelsUpdater::class),
            $eventDispatcher
        );

        $indexer->handle($message);
    }
}

class StackMiddlewareTest extends TestCase
{
    public function testClone()
    {
        $middleware1 = $this->createMock(MiddlewareInterface::class);
        $middleware1
            ->expects($this->once())
            ->method('handle')
            ->willReturnCallback(function DEnvelope $envelope, StackInterface $stack): Envelope {
                $fork = clone $stack;

                $stack->next()->handle($envelope, $stack);
                $fork->next()->handle($envelope, $fork);

                return $envelope;
            })
        ;

        $middleware2 = $this->createMock(MiddlewareInterface::class);
        $middleware2
            ->expects($this->exactly(2))
            ->method('handle')
            ->willReturnCallback(fn (Envelope $envelope, StackInterface $stack): Envelope => $envelope)
        ;

    private function addCriteriaParts(
        Criteria $criteria,
        ShopContextInterface $context,
        EsSearch $search,
        array $criteriaParts
    ) {
        foreach ($criteriaParts as $criteriaPart) {
            $handler = $this->handlerRegistry->getHandler($criteriaPart);

            $handler->handle($criteriaPart, $criteria, $search, $context);
        }
    }

    /** * @param array[] $data * * @return \Shopware\Bundle\StoreFrontBundle\Struct\BaseProduct[] */
    private function createProducts(array $data): array
    {
        $products = [];
        

        $cache = new HttpCache($kernel,
            $store,
            new Esi()
        );

        $request = Request::create('/');
        $request->server->set('REMOTE_ADDR', '10.0.0.1');

        // Main request         $cache->handle($request, HttpKernelInterface::MAIN_REQUEST);

        // Main request was now modified by HttpCache         // The surrogate will ask for the request using $this->cache->getRequest()         // which MUST return the original request so the surrogate         // can actually behave like a reverse proxy like e.g. Varnish would.         $this->assertSame('10.0.0.1', $cache->getRequest()->getClientIp());
        $this->assertSame('10.0.0.1', $cache->getRequest()->server->get('REMOTE_ADDR'));

        // Surrogate request         $cache->handle($request, HttpKernelInterface::SUB_REQUEST);
    }

    

    protected function forward(Request $request, bool $catch = false, Response $entry = null)
    {
        $this->surrogate?->addSurrogateCapability($request);

        // always a "master" request (as the real master request can be in cache)         $response = SubRequestHandler::handle($this->kernel, $request, HttpKernelInterface::MAIN_REQUEST, $catch);

        /* * Support stale-if-error given on Responses or as a config option. * RFC 7234 summarizes in Section 4.2.4 (but also mentions with the individual * Cache-Control directives) that * * A cache MUST NOT generate a stale response if it is prohibited by an * explicit in-protocol directive (e.g., by a "no-store" or "no-cache" * cache directive, a "must-revalidate" cache-response-directive, or an * applicable "s-maxage" or "proxy-revalidate" cache-response-directive; * see Section 5.2.2). * * https://tools.ietf.org/html/rfc7234#section-4.2.4 * * We deviate from this in one detail, namely that we *do* serve entries in the * stale-if-error case even if they have a `s-maxage` Cache-Control directive. */

    public function __construct(private ContainerInterface $container)
    {
    }

    public function indexAction()
    {
        $request = $this->container->get('request_stack')->getCurrentRequest();
        $path['_controller'] = self::class.'::fragmentAction';
        $subRequest = $request->duplicate([], null, $path);

        return $this->container->get('http_kernel')->handle($subRequest, HttpKernelInterface::SUB_REQUEST);
    }

    public function fragmentAction(LoggerInterface $logger)
    {
        return new Response('---');
    }
}