DummyPipelineFactory.java

package com.linkedin.databus2.core.container;
/*
 *
 * Copyright 2013 LinkedIn Corp. All rights reserved
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
*/


import java.nio.ByteOrder;
import java.util.List;
import java.util.Vector;

import org.jboss.netty.buffer.ChannelBuffer;
import org.jboss.netty.buffer.DynamicChannelBuffer;
import org.jboss.netty.channel.ChannelHandlerContext;
import org.jboss.netty.channel.ChannelPipeline;
import org.jboss.netty.channel.ChannelPipelineFactory;
import org.jboss.netty.channel.Channels;
import org.jboss.netty.channel.MessageEvent;
import org.jboss.netty.channel.SimpleChannelUpstreamHandler;

import com.linkedin.databus2.core.container.request.BinaryProtocol;
import com.linkedin.databus2.core.container.request.CommandsRegistry;
import com.linkedin.databus2.core.container.request.SimpleBinaryDatabusRequestDecoder;
import com.linkedin.databus2.core.container.request.SimpleBinaryDatabusResponseEncoder;

/** Used only for Espresso (databus3-relay) unit tests. */
public class DummyPipelineFactory
{
  public static final String RESPONSE_AGGREGATOR_NAME = "response aggregator";
  public static final String COMMAND_CAPTURE_NAME = "command capture";

  private static final int READ_TIMEOUT_MS = 500;

  public static class DummyServerPipelineFactory implements ChannelPipelineFactory
  {
    private final CommandsRegistry _cmdsRegistry;
    private final ByteOrder _byteOrder;

    public DummyServerPipelineFactory(CommandsRegistry cmdsRegistry, ByteOrder byteOrder)
    {
      _cmdsRegistry = cmdsRegistry;
      _byteOrder = byteOrder;
    }

    @Override
    public ChannelPipeline getPipeline() throws Exception
    {
      ChannelPipeline pipeline = Channels.pipeline();

      ExtendedReadTimeoutHandler readTimeoutHandler =
          new ExtendedReadTimeoutHandler("server container 1", null, READ_TIMEOUT_MS, true);
      pipeline.addLast("read timeout", readTimeoutHandler);

      pipeline.addLast("request decoder",
                       new SimpleBinaryDatabusRequestDecoder(_cmdsRegistry, readTimeoutHandler, _byteOrder));
      pipeline.addLast(COMMAND_CAPTURE_NAME, new SimpleObjectCaptureHandler());
      pipeline.addLast(SimpleBinaryDatabusRequestDecoder.REQUEST_EXEC_HANDLER_NAME,
                       new SimpleObjectCaptureHandler());
      pipeline.addLast("response encoder", new SimpleBinaryDatabusResponseEncoder());

      return pipeline;
    }
  }

  public static class DummyClientPipelineFactory implements ChannelPipelineFactory
  {

    @Override
    public ChannelPipeline getPipeline() throws Exception
    {
      ChannelPipeline pipeline = Channels.pipeline();
      pipeline.addLast(RESPONSE_AGGREGATOR_NAME,
                       new SimpleResponseBytesAggregatorHandler(BinaryProtocol.BYTE_ORDER));

      return pipeline;
    }
  }

  /**
   * A simple channel handler which records all message that  pass through it. The class is meant
   * mostly for testing purposes.*/
  public static class SimpleObjectCaptureHandler extends SimpleChannelUpstreamHandler
  {

    private final List<Object> _messages;

    public SimpleObjectCaptureHandler()
    {
      _messages = new Vector<Object>();
    }

    public void clear()
    {
      _messages.clear();
    }

    public List<Object> getMessages()
    {
      return _messages;
    }

    @Override
    public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception
    {
      _messages.add(e.getMessage());
      super.messageReceived(ctx, e);
    }

  }

  /**
   * A simple handler for testing purposes. It aggregates all ChannelBuffer responses into a single
   * channel buffer. */
  public static class SimpleResponseBytesAggregatorHandler extends SimpleChannelUpstreamHandler
  {
    private final ChannelBuffer _buffer;

    public SimpleResponseBytesAggregatorHandler(ByteOrder byteOrder)
    {
      _buffer = new DynamicChannelBuffer(byteOrder, 1000);
    }

    @Override
    public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception
    {
      if (e.getMessage() instanceof ChannelBuffer)
      {
        ChannelBuffer buf = (ChannelBuffer)e.getMessage();
        _buffer.writeBytes(buf);
      }

      super.messageReceived(ctx, e);
    }

    public ChannelBuffer getBuffer()
    {
      return _buffer;
    }

    public void clear()
    {
      _buffer.clear();
    }

  }


}