How to use org.jflux.impl.messaging.rk

  @Override
  void stop() {
    receiver.stop();
  }
}

SenderContext(String name, Session session, Destination destination, 
    Adapter<M,R> adapter) throws JMSException{
  super(name,session, destination);
  sender = new JMSAvroMessageSender(session, destination);
  sender.setAdapter(adapter);
}
@Override

AsyncReceiverContext(String name, 
    Session session, Destination destination, 
    Class<R> recordClass, Schema recordSchema,
    Adapter<R,M> adapter) throws JMSException{
  super(name,session, destination);
  receiver = new JMSAvroMessageAsyncReceiver<M, R>(
    session, destination, recordClass, recordSchema);
  receiver.setAdapter(adapter);
}
@Override

    new JMSAvroMessageSender<ServiceCommand, ServiceCommandRecord>(
        session, cmdDest);
JMSAvroMessageSender<CameraServiceConfig, CameraConfig> configSender = 
    new JMSAvroMessageSender<CameraServiceConfig, CameraConfig>(
        session, cmdDest);
JMSAvroMessageAsyncReceiver<ServiceError, ServiceErrorRecord> errorReceiver = 
    new JMSAvroMessageAsyncReceiver<ServiceError, ServiceErrorRecord>(
        session, errDest, 
        ServiceErrorRecord.class, ServiceErrorRecord.SCHEMA$);
ServiceCommandFactory cmdFactory = new PortableServiceCommand.Factory();
JMSAvroMessageAsyncReceiver<ImageEvent, ImageRecord> imageReceiver = 
    new JMSAvroMessageAsyncReceiver<ImageEvent, ImageRecord>(
        session, imgDest, 
        ImageRecord.class, ImageRecord.SCHEMA$);
        cmdFactory, imageReceiver);
cmdSender.setAdapter(new EmptyAdapter());
cmdSender.setDefaultContentType(JMSAvroServiceFacade.COMMAND_MIME_TYPE);
cmdSender.start();
errorReceiver.setAdapter(new EmptyAdapter());
errorReceiver.start();
imageReceiver.setAdapter(new EmptyAdapter());
imageReceiver.start();

  private ConsumerNode<SpeechRequest> buildTTSNodeChain(
      Session session, Destination dest){
    try{
      JMSAvroMessageSender<SpeechRequest,SpeechRequestRecord> sender = 
          new JMSAvroMessageSender<SpeechRequest, SpeechRequestRecord>(session, dest);
      sender.setAdapter(new EmptyAdapter());
      sender.setDefaultContentType("application/speechRequest");
      sender.start();
      return new DefaultConsumerNode<SpeechRequest>(sender);
//            return NodeChainBuilder.build(
//                    EncodeRequest.factory(SpeechRequest.class, new JMSAvroUtils.ByteOutputStreamFactory()))
//                .getConsumerChain(JMSAvroUtils.buildEventSenderChain(
//                    SpeechRequestRecord.class, 
//                    SpeechRequestRecord.SCHEMA$, 
//                    new EmptyAdapter(), 
//                    session, dest, 
//                    new MessageHeaderAdapter("application/speechRequest")));
    }catch(Exception ex){
      theLogger.log(Level.WARNING,"Error connecting to TTS.",ex);
      return null;
    }
  }
  

  private ProducerNode<SpeechRecEventList<SpeechRecEvent>> buildSpeechRecChain(
      Session session, Destination dest){
    JMSAvroMessageAsyncReceiver<SpeechRecEventList<SpeechRecEvent>, SpeechRecEventListRecord> rec = 
      new JMSAvroMessageAsyncReceiver<SpeechRecEventList<SpeechRecEvent>, SpeechRecEventListRecord>(
      session, dest, SpeechRecEventListRecord.class, SpeechRecEventListRecord.SCHEMA$);
    rec.setAdapter(new EmptyAdapter());
    try{
      rec.start();
    }catch(Exception ex){
      theLogger.log(Level.SEVERE, "Unable to start Message Receiver", ex);
      return null;
    }
    return new DefaultProducerNode<SpeechRecEventList<SpeechRecEvent>>(rec);
//        try{
//            return JMSAvroUtils.buildEventReceiverChain(
//                    SpeechRecEventListRecord.class, 
//                    SpeechRecEventListRecord.SCHEMA$, 
//                    new EmptyAdapter(), 
//                    session, dest);
//        }catch(JMSException ex){
//            theLogger.log(Level.WARNING,"Error connecting to Speech Rec.",ex);
//            return null;
//        }
  }
  

private static MessageSender<SpeechRequest> createSpeechSender(
    Session session, Destination dest){
  DefaultMessageSender<SpeechRequest, SpeechRequestRecord> sender =
      new DefaultMessageSender<SpeechRequest, SpeechRequestRecord>();
  JMSBytesMessageSender bytesSender = new JMSBytesMessageSender();
  bytesSender.setSession(session);
  bytesSender.setDestination(dest);
  RecordSender<SpeechRequestRecord> recSender =
      new JMSAvroRecordSender<SpeechRequestRecord>(bytesSender);
  sender.setAdapter(new EmptyAdapter());
  sender.setRecordSender(recSender);
  try{
    sender.start();
  }catch(Exception ex){
    theLogger.log(Level.SEVERE, "Error starting message sender.", ex);
    return null;
  }
  return sender;
}

@Override
void start() throws Exception{
  sender.start();
}
@Override

@Override
void start() throws Exception{
  receiver.start();
}
@Override

  @Override
  void stop() {
    sender.stop();
  }
}

BlockingReceiverContext(String name, 
    Session session, Destination destination, 
    Adapter<BytesMessage,M> adapter) throws JMSException{
  super(name,session, destination);
  MessageConsumer consumer = session.createConsumer(destination);
  JMSBytesRecordBlockingReceiver recReceiver = 
      new JMSBytesRecordBlockingReceiver(consumer);
  receiver = new DefaultMessageBlockingReceiver<M,BytesMessage>();
  receiver.setRecordReceiver(recReceiver);
  receiver.setAdapter(adapter);
}
@Override

private static MessageAsyncReceiver<SpeechRequest> createSpeechReceiver(
    Session session, Destination dest){
  DefaultMessageAsyncReceiver<SpeechRequest, SpeechRequestRecord> receiver =
      new DefaultMessageAsyncReceiver<SpeechRequest,
          SpeechRequestRecord>();
  MessageConsumer consumer;
  try{
    consumer = session.createConsumer(dest);
  }catch(JMSException ex){
    theLogger.log(Level.SEVERE, "Error starting message receiver.", ex);
    return null;
  }
  RecordAsyncReceiver<SpeechRequestRecord> recReceiver =
      new JMSAvroRecordAsyncReceiver<SpeechRequestRecord>(
          SpeechRequestRecord.class,
          SpeechRequestRecord.SCHEMA$,
          consumer);
  receiver.setRecordReceiver(recReceiver);
  receiver.setAdapter(new EmptyAdapter());
  return receiver;
}

    new JMSAvroMessageSender<ServiceCommand, ServiceCommandRecord>(
        session, cmdDest);
JMSAvroMessageSender<FaceDetectServiceConfig, FaceDetectConfig> configSender = 
    new JMSAvroMessageSender<FaceDetectServiceConfig, FaceDetectConfig>(
        session, cmdDest);
JMSAvroMessageAsyncReceiver<ServiceError, ServiceErrorRecord> errorReceiver = 
    new JMSAvroMessageAsyncReceiver<ServiceError, ServiceErrorRecord>(
        session, errDest, 
        ServiceErrorRecord.class, ServiceErrorRecord.SCHEMA$);
ServiceCommandFactory cmdFactory = new PortableServiceCommand.Factory();
JMSAvroMessageAsyncReceiver<ImageRegionList, ImageRegionListRecord> imageRgnReceiver = 
    new JMSAvroMessageAsyncReceiver<ImageRegionList, ImageRegionListRecord>(
        session, imgRgnDest, 
        ImageRegionListRecord.class, 
        cmdFactory, imageRgnReceiver);
cmdSender.setAdapter(new EmptyAdapter());
cmdSender.setDefaultContentType(JMSAvroServiceFacade.COMMAND_MIME_TYPE);
cmdSender.start();
errorReceiver.setAdapter(new EmptyAdapter());
errorReceiver.start();
imageRgnReceiver.setAdapter(new EmptyAdapter());
imageRgnReceiver.start();        

  private ConsumerNode<ServiceCommand> buildServiceCommandNodeChain(
      Session session, Destination dest){
    try{
      JMSAvroMessageSender<ServiceCommand,ServiceCommandRecord> sender = 
          new JMSAvroMessageSender<ServiceCommand, ServiceCommandRecord>(session, dest);
      sender.setAdapter(new EmptyAdapter());
      sender.setDefaultContentType("application/service-command");
      sender.start();
      return new DefaultConsumerNode<ServiceCommand>(sender);
    }catch(Exception ex){
      theLogger.log(Level.WARNING,"Error connecting to TTS.",ex);
      return null;
    }
//        try{
//            return NodeChainBuilder.build(
//                    EncodeRequest.factory(ServiceCommand.class, new JMSAvroUtils.ByteOutputStreamFactory()))
//                .getConsumerChain(JMSAvroUtils.buildEventSenderChain(
//                    ServiceCommandRecord.class, 
//                    ServiceCommandRecord.SCHEMA$, 
//                    new EmptyAdapter(), 
//                    session, dest, 
//                    new MessageHeaderAdapter("application/service-command")));
//        }catch(JMSException ex){
//            theLogger.log(Level.WARNING,"Error connecting to TTS.",ex);
//            return null;
//        }
  }
  

  private ProducerNode<SpeechRecEventList<SpeechRecEvent>> buildSpeechRecChain(
      Session session, Destination dest){
    JMSAvroMessageAsyncReceiver<SpeechRecEventList<SpeechRecEvent>, SpeechRecEventListRecord> rec = 
      new JMSAvroMessageAsyncReceiver<SpeechRecEventList<SpeechRecEvent>, SpeechRecEventListRecord>(
      session, dest, SpeechRecEventListRecord.class, SpeechRecEventListRecord.SCHEMA$);
    rec.setAdapter(new EmptyAdapter());
    try{
      rec.start();
    }catch(Exception ex){
      theLogger.log(Level.SEVERE, "Unable to start Message Receiver", ex);
      return null;
    }
    return new DefaultProducerNode<SpeechRecEventList<SpeechRecEvent>>(rec);
//        try{
//            return JMSAvroUtils.buildEventReceiverChain(
//                    SpeechRecEventListRecord.class, 
//                    SpeechRecEventListRecord.SCHEMA$, 
//                    new EmptyAdapter(), 
//                    session, dest);
//        }catch(JMSException ex){
//            theLogger.log(Level.WARNING,"Error connecting to Speech Rec.",ex);
//            return null;
//        }
  }
  

  private ConsumerNode<SpeechRequest> buildTTSNodeChain(
      Session session, Destination dest){
    try{
      JMSAvroMessageSender<SpeechRequest,SpeechRequestRecord> sender = 
          new JMSAvroMessageSender<SpeechRequest, SpeechRequestRecord>(session, dest);
      sender.setAdapter(new EmptyAdapter());
      sender.setDefaultContentType("application/speechRequest");
      sender.start();
      return new DefaultConsumerNode<SpeechRequest>(sender);
//            return NodeChainBuilder.build(
//                    EncodeRequest.factory(SpeechRequest.class, new JMSAvroUtils.ByteOutputStreamFactory()))
//                .getConsumerChain(JMSAvroUtils.buildEventSenderChain(
//                    SpeechRequestRecord.class, 
//                    SpeechRequestRecord.SCHEMA$, 
//                    new EmptyAdapter(), 
//                    session, dest, 
//                    new MessageHeaderAdapter("application/speechRequest")));
    }catch(Exception ex){
      theLogger.log(Level.WARNING,"Error connecting to TTS.",ex);
      return null;
    }
  }
  

  private ConsumerNode<ServiceCommand> buildServiceCommandNodeChain(
      Session session, Destination dest){
    try{
      JMSAvroMessageSender<ServiceCommand,ServiceCommandRecord> sender = 
          new JMSAvroMessageSender<ServiceCommand, ServiceCommandRecord>(session, dest);
      sender.setAdapter(new EmptyAdapter());
      sender.setDefaultContentType("application/service-command");
      sender.start();
      return new DefaultConsumerNode<ServiceCommand>(sender);
    }catch(Exception ex){
      theLogger.log(Level.WARNING,"Error connecting to TTS.",ex);
      return null;
    }
//        try{
//            return NodeChainBuilder.build(
//                    EncodeRequest.factory(ServiceCommand.class, new JMSAvroUtils.ByteOutputStreamFactory()))
//                .getConsumerChain(JMSAvroUtils.buildEventSenderChain(
//                    ServiceCommandRecord.class, 
//                    ServiceCommandRecord.SCHEMA$, 
//                    new EmptyAdapter(), 
//                    session, dest, 
//                    new MessageHeaderAdapter("application/service-command")));
//        }catch(JMSException ex){
//            theLogger.log(Level.WARNING,"Error connecting to TTS.",ex);
//            return null;
//        }
  }