io.hyperfoil.core.handlers.PassthroughHandler Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of hyperfoil-core Show documentation
The core of Hyperfoil
There is a newer version: 0.27.1
package io.hyperfoil.core.handlers;

import org.kohsuke.MetaInfServices;

import io.hyperfoil.api.config.BenchmarkDefinitionException;
import io.hyperfoil.api.config.Locator;
import io.hyperfoil.api.config.Step;
import io.hyperfoil.api.connection.HttpRequest;
import io.hyperfoil.api.connection.Processor;
import io.hyperfoil.api.http.BodyHandler;
import io.hyperfoil.api.session.ResourceUtilizer;
import io.hyperfoil.api.session.Session;
import io.hyperfoil.core.steps.ServiceLoadedBuilderProvider;
import io.hyperfoil.function.SerializableSupplier;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;

public class PassthroughHandler implements BodyHandler, ResourceUtilizer {
   private final Processor delegate;

   public PassthroughHandler(Processor delegate) {
      this.delegate = delegate;
   }

   @Override
   public void beforeData(HttpRequest request) {
      delegate.before(request);
   }

   @Override
   public void handleData(HttpRequest request, ByteBuf data) {
      delegate.process(request, data, data.readerIndex(), data.readableBytes(), false);
   }

   @Override
   public void afterData(HttpRequest request) {
      delegate.process(request, Unpooled.EMPTY_BUFFER, 0, 0, true);
      delegate.after(request);
   }

   @Override
   public void reserve(Session session) {
      ResourceUtilizer.reserve(session, delegate);
   }

   /**
    * Adapter sending the body to a processor.
    */
   public static class Builder implements BodyHandler.Builder {
      private Processor.Builder processor;
      private boolean defrag = true;

      public Builder processor(Processor.Builder processor) {
         this.processor = processor;
         return this;
      }

      /**
       * Processor that this handler delegates to.
       *
       * @return Builder.
       */
      public ServiceLoadedBuilderProvider, HttpRequest.ProcessorBuilderFactory> processor() {
         return new ServiceLoadedBuilderProvider<>(HttpRequest.ProcessorBuilderFactory.class, null, this::processor);
      }

      /**
       * Automatically defragment the body, passing the whole response in single chunk.
       *
       * @param defrag Do defrag?
       * @return Self.
       */
      public Builder defrag(boolean defrag) {
         this.defrag = defrag;
         return this;
      }

      @Override
      public PassthroughHandler build(SerializableSupplier step) {
         if (processor == null) {
            throw new BenchmarkDefinitionException("Processor must be set.");
         }
         Processor processor = this.processor.build();
         return new PassthroughHandler(defrag ? new DefragProcessor<>(processor) : processor);
      }
   }

   @MetaInfServices(BodyHandler.BuilderFactory.class)
   public static class BuilderFactory implements BodyHandler.BuilderFactory {
      @Override
      public String name() {
         return "passthrough";
      }

      @Override
      public boolean acceptsParam() {
         return false;
      }

      @Override
      public PassthroughHandler.Builder newBuilder(Locator locator, String param) {
         return new PassthroughHandler.Builder();
      }
   }
}