Project: Flume-Hive
/**
 * Licensed to Cloudera, Inc. under one 
 * or more contributor license agreements.  See the NOTICE file 
 * distributed with this work for additional information 
 * regarding copyright ownership.  Cloudera, Inc. licenses this file 
 * to you 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. 
 */
package com.cloudera.flume.core; 
 
import java.io.IOException; 
 
import com.cloudera.flume.master.StatusManager.NodeState; 
 
/**
 * This is an edge that connects a source to a sink. This is an abstract class 
 * because we can have many different properties for the connection between 
 * them. 
 *  
 * The default will be a direct connection - synchronous, single thread, single 
 * stack. 
 *  
 * Others could include a asynchronous versions that use a lifo or pqueue that 
 * allows for multiple threads of consumers. 
 */
 
abstract public class Driver { 
 
  abstract public EventSource getSource(); 
 
  abstract public EventSink getSink(); 
 
  abstract public void setSource(EventSource src); 
 
  abstract public void setSink(EventSink snk); 
 
  /**
   * Signals driver to start. This blocks until the driver has started 
   */
 
  abstract public void start() throws IOException; 
 
  /**
   * Signals driver to do a stop that attempts to flush any internal buffers. 
   * This does not block. 
   */
 
  abstract public void stop() throws IOException; 
 
  /**
   * Signals driver to do a abrupt shutdown. This does not guarantee that any 
   * internal buffers will be flushed. This does not block. 
   */
 
  abstract public void cancel(); 
 
  /**
   * This causes the driver to block until it is "done". 
   */
 
  abstract public void join() throws InterruptedException; 
 
  /**
   * return true if the driver has completed within specified ms. If it has not 
   * completed by the specified time, it returns false. 0 ms means wait forever 
   */
 
  abstract public boolean join(long ms) throws InterruptedException; 
 
  abstract public NodeState getState(); 
 
  abstract public void registerListener(DriverListener listener); 
 
  abstract public void deregisterListener(DriverListener listener); 
}