protected synchronized void flushToDisk() {
   if (!memoryList.isEmpty() && store != null) {
     long start = 0;
     if (LOG.isTraceEnabled()) {
       start = System.currentTimeMillis();
       LOG.trace(
           "{}, flushToDisk() mem list size: {} {}",
           new Object[] {
             name, memoryList.size(), (systemUsage != null ? systemUsage.getMemoryUsage() : "")
           });
     }
     for (Iterator<MessageReference> iterator = memoryList.iterator(); iterator.hasNext(); ) {
       MessageReference node = iterator.next();
       node.decrementReferenceCount();
       ByteSequence bs;
       try {
         bs = getByteSequence(node.getMessage());
         getDiskList().addLast(node.getMessageId().toString(), bs);
       } catch (IOException e) {
         LOG.error("Failed to write to disk list", e);
         throw new RuntimeException(e);
       }
     }
     memoryList.clear();
     setCacheEnabled(false);
     LOG.trace(
         "{}, flushToDisk() done - {} ms {}",
         new Object[] {
           name,
           (System.currentTimeMillis() - start),
           (systemUsage != null ? systemUsage.getMemoryUsage() : "")
         });
   }
 }
 private void discardExpiredMessage(MessageReference reference) {
   LOG.debug("Discarding expired message {}", reference);
   if (broker.isExpired(reference)) {
     ConnectionContext context = new ConnectionContext(new NonCachedMessageEvaluationContext());
     context.setBroker(broker);
     ((Destination) reference.getRegionDestination())
         .messageExpired(context, null, new IndirectMessageReference(reference.getMessage()));
   }
 }
 @Override
 public synchronized void destroy() throws Exception {
   stop();
   for (Iterator<MessageReference> i = memoryList.iterator(); i.hasNext(); ) {
     MessageReference node = i.next();
     node.decrementReferenceCount();
   }
   memoryList.clear();
   destroyDiskList();
 }
 protected synchronized void expireOldMessages() {
   if (!memoryList.isEmpty()) {
     for (Iterator<MessageReference> iterator = memoryList.iterator(); iterator.hasNext(); ) {
       MessageReference node = iterator.next();
       if (node.isExpired()) {
         node.decrementReferenceCount();
         discardExpiredMessage(node);
         iterator.remove();
       }
     }
   }
 }
 /** @return the next pending message */
 @Override
 public synchronized MessageReference next() {
   MessageReference reference = iter.next();
   last = reference;
   if (!isDiskListEmpty()) {
     // got from disk
     reference.getMessage().setRegionDestination(regionDestination);
     reference.getMessage().setMemoryUsage(this.getSystemUsage().getMemoryUsage());
   }
   reference.incrementReferenceCount();
   return reference;
 }
 /**
  * @param node
  * @see
  *     org.apache.activemq.broker.region.cursors.AbstractPendingMessageCursor#remove(org.apache.activemq.broker.region.MessageReference)
  */
 @Override
 public synchronized void remove(MessageReference node) {
   if (memoryList.remove(node) != null) {
     node.decrementReferenceCount();
   }
   if (!isDiskListEmpty()) {
     try {
       getDiskList().remove(node.getMessageId().getPlistLocator());
     } catch (IOException e) {
       throw new RuntimeException(e);
     }
   }
 }
 @Override
 public synchronized void addMessageFirst(MessageReference node) throws Exception {
   batchList.addMessageFirst(node);
   size++;
   node.incrementReferenceCount();
   // this.messageSize.addSize(node.getMessage().getSize());
 }
 /** @return true if there are no pending messages */
 @Override
 public synchronized boolean isEmpty() {
   if (memoryList.isEmpty() && isDiskListEmpty()) {
     return true;
   }
   for (Iterator<MessageReference> iterator = memoryList.iterator(); iterator.hasNext(); ) {
     MessageReference node = iterator.next();
     if (node == QueueMessageReference.NULL_MESSAGE) {
       continue;
     }
     if (!node.isDropped()) {
       return false;
     }
     // We can remove dropped references.
     iterator.remove();
   }
   return isDiskListEmpty();
 }
 public Message[] browse(ActiveMQDestination destination) throws Exception {
   final List<Message> result = new ArrayList<Message>();
   if (retainedMessage != null) {
     DestinationFilter filter = DestinationFilter.parseFilter(destination);
     if (filter.matches(retainedMessage.getMessage().getDestination())) {
       result.add(retainedMessage.getMessage());
     }
   }
   Message[] messages = result.toArray(new Message[result.size()]);
   if (wrapped != null) {
     final Message[] wrappedMessages = wrapped.browse(destination);
     if (wrappedMessages != null && wrappedMessages.length > 0) {
       final int origLen = messages.length;
       messages = Arrays.copyOf(messages, origLen + wrappedMessages.length);
       System.arraycopy(wrappedMessages, 0, messages, origLen, wrappedMessages.length);
     }
   }
   return messages;
 }
  @Override
  public void messageDelivered(ConnectionContext context, MessageReference messageReference) {
    if (isLogAll() || isLogConsumerEvents() || isLogInternalEvents()) {
      String msg = "Unable to display message.";

      msg = messageReference.getMessage().toString();

      LOG.info("Message delivered: {}", msg);
    }
    super.messageDelivered(context, messageReference);
  }
 public boolean add(ConnectionContext context, MessageReference node) throws Exception {
   final Message message = node.getMessage();
   final Object retainValue = message.getProperty(RETAIN_PROPERTY);
   // retain property set to true
   final boolean retain = retainValue != null && Boolean.parseBoolean(retainValue.toString());
   if (retain) {
     if (message.getContent().getLength() > 0) {
       // non zero length message content
       retainedMessage = message.copy();
       retainedMessage.getMessage().removeProperty(RETAIN_PROPERTY);
       retainedMessage.getMessage().setProperty(RETAINED_PROPERTY, true);
     } else {
       // clear retained message
       retainedMessage = null;
     }
     // TODO should we remove the publisher's retain property??
     node.getMessage().removeProperty(RETAIN_PROPERTY);
   }
   return wrapped == null ? true : wrapped.add(context, node);
 }
  @Override
  public void messageExpired(
      ConnectionContext context, MessageReference message, Subscription subscription) {
    if (isLogAll() || isLogInternalEvents()) {
      String msg = "Unable to display message.";

      msg = message.getMessage().toString();

      LOG.info("Message has expired: {}", msg);
    }
    super.messageExpired(context, message, subscription);
  }
 @Override
 public synchronized LinkedList<MessageReference> pageInList(int maxItems) {
   LinkedList<MessageReference> result = new LinkedList<MessageReference>();
   int count = 0;
   for (Iterator<MessageReference> i = memoryList.iterator(); i.hasNext() && count < maxItems; ) {
     MessageReference ref = i.next();
     ref.incrementReferenceCount();
     result.add(ref);
     count++;
   }
   if (count < maxItems && !isDiskListEmpty()) {
     for (Iterator<MessageReference> i = new DiskIterator(); i.hasNext() && count < maxItems; ) {
       Message message = (Message) i.next();
       message.setRegionDestination(regionDestination);
       message.setMemoryUsage(this.getSystemUsage().getMemoryUsage());
       message.incrementReferenceCount();
       result.add(message);
       count++;
     }
   }
   return result;
 }
  @Override
  public boolean sendToDeadLetterQueue(
      ConnectionContext context,
      MessageReference messageReference,
      Subscription subscription,
      Throwable poisonCause) {
    if (isLogAll() || isLogInternalEvents()) {
      String msg = "Unable to display message.";

      msg = messageReference.getMessage().toString();

      LOG.info("Sending to DLQ: {}", msg);
    }
    return super.sendToDeadLetterQueue(context, messageReference, subscription, poisonCause);
  }
  /**
   * add message to await dispatch
   *
   * @param node
   */
  @Override
  public synchronized void addMessageFirst(MessageReference node) {
    if (!node.isExpired()) {
      try {
        regionDestination = (Destination) node.getMessage().getRegionDestination();
        if (isDiskListEmpty()) {
          if (hasSpace()) {
            memoryList.addMessageFirst(node);
            node.incrementReferenceCount();
            setCacheEnabled(true);
            return;
          }
        }
        if (!hasSpace()) {
          if (isDiskListEmpty()) {
            expireOldMessages();
            if (hasSpace()) {
              memoryList.addMessageFirst(node);
              node.incrementReferenceCount();
              return;
            } else {
              flushToDisk();
            }
          }
        }
        systemUsage.getTempUsage().waitForSpace();
        node.decrementReferenceCount();
        ByteSequence bs = getByteSequence(node.getMessage());
        Object locator = getDiskList().addFirst(node.getMessageId().toString(), bs);
        node.getMessageId().setPlistLocator(locator);

      } catch (Exception e) {
        LOG.error(
            "Caught an Exception adding a message: {} first to FilePendingMessageCursor ", node, e);
        throw new RuntimeException(e);
      }
    } else {
      discardExpiredMessage(node);
    }
  }
  @Override
  public synchronized boolean tryAddMessageLast(MessageReference node, long maxWaitTime)
      throws Exception {
    if (!node.isExpired()) {
      try {
        regionDestination = (Destination) node.getMessage().getRegionDestination();
        if (isDiskListEmpty()) {
          if (hasSpace() || this.store == null) {
            memoryList.addMessageLast(node);
            node.incrementReferenceCount();
            setCacheEnabled(true);
            return true;
          }
        }
        if (!hasSpace()) {
          if (isDiskListEmpty()) {
            expireOldMessages();
            if (hasSpace()) {
              memoryList.addMessageLast(node);
              node.incrementReferenceCount();
              return true;
            } else {
              flushToDisk();
            }
          }
        }
        if (systemUsage.getTempUsage().waitForSpace(maxWaitTime)) {
          ByteSequence bs = getByteSequence(node.getMessage());
          getDiskList().addLast(node.getMessageId().toString(), bs);
          return true;
        }
        return false;

      } catch (Exception e) {
        LOG.error(
            "Caught an Exception adding a message: {} first to FilePendingMessageCursor ", node, e);
        throw new RuntimeException(e);
      }
    } else {
      discardExpiredMessage(node);
    }
    // message expired
    return true;
  }
 public boolean isAllowedToConsume(MessageReference n) throws IOException {
   if (messageAuthorizationPolicy != null) {
     return messageAuthorizationPolicy.isAllowedToConsume(this, n.getMessage());
   }
   return true;
 }