Ejemplo n.º 1
0
  public void send(Message message) {
    try {
      // force keyframe? ditch all the other messages on the queue
      // since this message will overwrite everything
      if (message.isBlockMessage() && ((BlockMessage) message).getForceKeyFrame()) {
        blockDataQ.clear();
        notifyQueueListener(0);
      }
      // stick message on queue
      blockDataQ.put(message);

      // if the queue is backed up, purge it of duplicate blocks
      int qSizeInBlocks = getQueueSizeInBlocks();
      if (qSizeInBlocks > ScreenShareInfo.MAX_QUEUE_SIZE_FOR_PAUSE) {
        if (ScreenShareInfo.getPurgeBackedUpQueue()) {
          purgeBlockDataQ();
        }
        notifyQueueListener(qSizeInBlocks);
      }

      // if we're being slow, notify also
      if (ScreenShareInfo.adjustPauseFromQueueSize && perfStats.isSlow()) {
        notifyPerformanceListener(true);
      }

    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }
Ejemplo n.º 2
0
@ThreadSafe
public class NetworkStreamSender implements NextBlockRetriever, NetworkStreamListener {

  public static final String NAME = "NETWORKSTREAMSENDER: ";

  private ExecutorService executor;
  private LinkedBlockingQueue<Message> blockDataQ;
  private final int numThreads;
  private final String host;
  private final int port;
  private final String room;
  private final boolean httpTunnel;
  private NetworkSocketStreamSender[] socketSenders;
  private NetworkHttpStreamSender[] httpSenders;
  private boolean tunneling = false;
  private boolean stopped = true;
  private int numRunningThreads = 0;
  private Dimension screenDim;
  private Dimension blockDim;
  private BlockManager blockManager;
  private NetworkConnectionListener listener;
  private QueueListener queueListener;
  private PerformanceListener performanceListener;
  private final SequenceNumberGenerator seqNumGenerator = new SequenceNumberGenerator();
  private PerformanceStats perfStats = PerformanceStats.getInstance();

  public NetworkStreamSender(
      BlockManager blockManager,
      String host,
      int port,
      String room,
      Dimension screenDim,
      Dimension blockDim,
      boolean httpTunnel) {
    blockDataQ = new LinkedBlockingQueue<Message>(ScreenShareInfo.MAX_QUEUED_MESSAGES);

    this.blockManager = blockManager;
    this.host = host;
    this.port = port;
    this.room = room;
    this.screenDim = screenDim;
    this.blockDim = blockDim;
    this.httpTunnel = httpTunnel;

    numThreads = ScreenShareInfo.NETWORK_SENDER_COUNT;
    System.out.println(NAME + "Starting up " + numThreads + " sender threads.");
    executor = Executors.newFixedThreadPool(numThreads);
  }

  public void addNetworkConnectionListener(NetworkConnectionListener listener) {
    this.listener = listener;
  }

  public void addQueueListener(QueueListener queueListener) {
    this.queueListener = queueListener;
  }

  public void addPerformanceListener(PerformanceListener performanceListener) {
    this.performanceListener = performanceListener;
  }

  private void notifyNetworkConnectionListener(ExitCode reason) {
    if (listener != null) {
      listener.networkConnectionException(reason);
    }
  }

  private void notifyQueueListener(int queueSize) {
    if (queueListener != null) {
      if (queueSize == 0) {
        queueListener.onQueueCleared();
      } else {
        queueListener.onQueueBackedup(queueSize);
      }
    }
  }

  private void notifyPerformanceListener(boolean slow) {
    if (performanceListener != null) {
      performanceListener.onSlowPerformance(slow);
    }
  }

  public boolean connect() {
    int failedAttempts = 0;

    socketSenders = new NetworkSocketStreamSender[numThreads];

    try {
      NetworkSocket socket = new NetworkSocket(host, port);

      for (int i = 0; i < numThreads; i++) {
        try {

          createSender(i, socket);
          numRunningThreads++;
        } catch (ConnectionException e) {
          failedAttempts++;
        }
      }

    } catch (ConnectionException e) {
      e.printStackTrace();
      failedAttempts = numThreads;
    }

    if ((failedAttempts == numThreads) && httpTunnel) {
      System.out.println(NAME + "Trying http tunneling");
      failedAttempts = 0;
      numRunningThreads = 0;
      if (tryHttpTunneling()) {
        tunneling = true;
        System.out.println(NAME + "Will use http tunneling");
        httpSenders = new NetworkHttpStreamSender[numThreads];
        for (int i = 0; i < numThreads; i++) {
          try {
            createHttpSender(i);
            numRunningThreads++;
          } catch (ConnectionException e) {
            failedAttempts++;
          }
        }
        return failedAttempts != numThreads;
      }
    } else {
      if (numRunningThreads != numThreads) {
        try {
          stop();
        } catch (ConnectionException e) {
          e.printStackTrace();
        }
        return false;
      } else {
        return true;
      }
    }
    System.out.println(NAME + "Http tunneling failed.");
    return false;
  }

  private void createSender(int i, NetworkSocket socket) throws ConnectionException {
    socketSenders[i] =
        new NetworkSocketStreamSender(i, this, room, screenDim, blockDim, seqNumGenerator);
    socketSenders[i].addListener(this);
    socketSenders[i].connect(socket);
  }

  private void createHttpSender(int i) throws ConnectionException {
    httpSenders[i] =
        new NetworkHttpStreamSender(i, this, room, screenDim, blockDim, seqNumGenerator);
    httpSenders[i].addListener(this);
    httpSenders[i].connect(host);
  }

  /**
   * this examines the block data queue for messages that may include the same blocks and discards
   * any dupe blocks todo: refactor this nastiness
   */
  private synchronized void purgeBlockDataQ() {
    Message message, nextMessage;
    BlockMessage blockMessage, nextBlockMessage;
    Integer[] blocks, nextBlocks;
    boolean skipMessage = false;
    int currentMessage = 0;
    LinkedBlockingQueue<Message> cloneQ =
        new LinkedBlockingQueue<Message>(ScreenShareInfo.MAX_QUEUED_MESSAGES);
    AtomicLong startTime = new AtomicLong(System.currentTimeMillis());

    Iterator it = blockDataQ.iterator();
    while (it.hasNext()) {
      message = (Message) it.next();
      skipMessage = false;
      ++currentMessage;

      // we only care about block messages that are keyframes
      // and have another block message after them
      // to dedupe against
      if (!(message.isBlockMessage() && ((BlockMessage) message).getForceKeyFrame())
          && it.hasNext()) {
        continue;
      }

      blockMessage = (BlockMessage) message;
      blocks = blockMessage.getBlocks();

      // look at the next block message to see if it overlaps with this one
      nextMessage = null;
      while (it.hasNext()) {
        nextMessage = (Message) it.next();
        if (!nextMessage.isBlockMessage()) {
          nextMessage = null;
          continue;
        }
      }

      // now compare the blocks between this msg and the next block message
      if (nextMessage != null) {
        nextBlockMessage = (BlockMessage) nextMessage;
        nextBlocks = nextBlockMessage.getBlocks();

        // exactly the same? ditch the whole message
        if (nextBlockMessage.hasSameBlocksAs(blockMessage)) {
          skipMessage = true;
        } else {
          // not exactly the same? See if we can prune dupe blocks
          blockMessage.discardBlocksSharedWith(nextBlockMessage);
          skipMessage = (nextBlockMessage.isEmpty());
        }
      }

      // if the current message must be retained, put it on the clone queue
      if (skipMessage) {
        continue;
      }
      try {
        cloneQ.put(message);
      } catch (InterruptedException e) {
        // System.out.println("Can't put message on clone queue");
      }
    }

    // we've looked at the whole queue, so time to swap in clone for real queue
    try {
      blockDataQ.clear();
      for (Message cloneMessage : cloneQ) {
        blockDataQ.put(cloneMessage);
      }
    } catch (InterruptedException e) {
      // System.out.println("Can't dump clone queue into queue");
    }
  }

  public void send(Message message) {
    try {
      // force keyframe? ditch all the other messages on the queue
      // since this message will overwrite everything
      if (message.isBlockMessage() && ((BlockMessage) message).getForceKeyFrame()) {
        blockDataQ.clear();
        notifyQueueListener(0);
      }
      // stick message on queue
      blockDataQ.put(message);

      // if the queue is backed up, purge it of duplicate blocks
      int qSizeInBlocks = getQueueSizeInBlocks();
      if (qSizeInBlocks > ScreenShareInfo.MAX_QUEUE_SIZE_FOR_PAUSE) {
        if (ScreenShareInfo.getPurgeBackedUpQueue()) {
          purgeBlockDataQ();
        }
        notifyQueueListener(qSizeInBlocks);
      }

      // if we're being slow, notify also
      if (ScreenShareInfo.adjustPauseFromQueueSize && perfStats.isSlow()) {
        notifyPerformanceListener(true);
      }

    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }

  public void start() {
    System.out.println(NAME + "Starting network sender.");
    if (tunneling) {
      for (int i = 0; i < numRunningThreads; i++) {
        httpSenders[i].sendStartStreamMessage();
        executor.execute(httpSenders[i]);
      }
    } else {
      for (int i = 0; i < numRunningThreads; i++) {
        try {
          socketSenders[i].sendStartStreamMessage();
          executor.execute(socketSenders[i]);
        } catch (ConnectionException e) {
          e.printStackTrace();
        }
      }
    }
    stopped = false;
  }

  public void stop() throws ConnectionException {
    stopped = true;
    System.out.println(NAME + "Stopping network sender");
    for (int i = 0; i < numRunningThreads; i++) {
      if (tunneling) {
        httpSenders[i].disconnect();
      } else {
        socketSenders[i].disconnect();
      }
    }
    executor.shutdownNow();
    httpSenders = null;
    socketSenders = null;
  }

  private boolean tryHttpTunneling() {
    NetworkHttpStreamSender httpSender =
        new NetworkHttpStreamSender(0, this, room, screenDim, blockDim, seqNumGenerator);
    try {
      httpSender.connect(host);
      return true;
    } catch (ConnectionException e) {
      System.out.println(NAME + "Problem connecting to " + host);
    }
    return false;
  }

  public void blockSent(int position) {
    blockManager.blockSent(position);
  }

  public EncodedBlockData getBlockToSend(int position) {
    return blockManager.getBlock(position).encode();
  }

  public Message getNextMessageToSend() throws InterruptedException {
    try {
      return blockDataQ.take();
    } catch (InterruptedException e) {
      if (!stopped) {
        e.printStackTrace();
      }
      throw e;
    }
  }

  public void networkException(int id, ExitCode reason) {
    try {
      numRunningThreads--;
      if (tunneling) {
        // httpSenders[id].disconnect();
        System.out.println(NAME + "Failed to use http tunneling. Stopping.");
        stop();
        notifyNetworkConnectionListener(reason);
      } else {
        socketSenders[id].disconnect();
      }
      if (numRunningThreads < 1) {
        System.out.println(NAME + "No more sender threads. Stopping.");
        stop();
        notifyNetworkConnectionListener(reason);
      } else {
        System.out.println(
            NAME + "Sender thread stopped. " + numRunningThreads + " sender threads remaining.");
      }
    } catch (ConnectionException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
      if (numRunningThreads < 1) {
        System.out.println(NAME + "No more sender threads. Stopping.");
        notifyNetworkConnectionListener(reason);
      } else {
        System.out.println(
            NAME + "Sender thread stopped. " + numRunningThreads + " sender threads remaining.");
      }
    }
  }

  // utility function, remove me
  private int getQueueSizeInBlocks() {
    int numBlocks = 0;
    for (Message message : blockDataQ) {
      if (message.isBlockMessage()) {
        numBlocks += ((BlockMessage) message).size();
      }
    }
    return numBlocks;
  }
}