Exemplo n.º 1
0
  @Test
  public void testGetNumberOfBytesPerPage() throws Exception {
    SimpleString address = RandomUtil.randomSimpleString();
    session.createQueue(address, address, true);

    AddressControl addressControl = createManagementControl(address);
    Assert.assertEquals(
        HornetQDefaultConfiguration.getDefaultJournalFileSize(),
        addressControl.getNumberOfBytesPerPage());

    session.close();
    server.stop();

    AddressSettings addressSettings = new AddressSettings();
    addressSettings.setPageSizeBytes(1024);

    server.getAddressSettingsRepository().addMatch(address.toString(), addressSettings);
    server.start();
    ServerLocator locator2 =
        HornetQClient.createServerLocatorWithoutHA(
            new TransportConfiguration(UnitTestCase.INVM_CONNECTOR_FACTORY));
    addServerLocator(locator2);
    ClientSessionFactory sf2 = createSessionFactory(locator2);

    session = sf2.createSession(false, true, false);
    session.createQueue(address, address, true);
    Assert.assertEquals(1024, addressControl.getNumberOfBytesPerPage());
  }
Exemplo n.º 2
0
 private void configurePaging() {
   AddressSettings addressSettings = new AddressSettings();
   addressSettings.setAddressFullMessagePolicy(AddressFullMessagePolicy.PAGE);
   addressSettings.setMaxSizeBytes(30 * 1024 * 1024);
   addressSettings.setPageSizeBytes(10 * 1024 * 1024);
   addressSettings.setPageCacheMaxSize(20);
   config.getAddressesSettings().put("jms.queue.*", addressSettings);
 }
Exemplo n.º 3
0
  /**
   * Create a setting.
   *
   * @param context the operation context
   * @param config the detyped config
   * @return the address settings
   * @throws OperationFailedException if the model is invalid
   */
  static AddressSettings createSettings(final OperationContext context, final ModelNode config)
      throws OperationFailedException {
    final AddressSettings settings = new AddressSettings();

    if (config.hasDefined(AddressSettingDefinition.ADDRESS_FULL_MESSAGE_POLICY.getName())) {
      final AddressFullMessagePolicy addressPolicy =
          AddressFullMessagePolicy.valueOf(
              AddressSettingDefinition.ADDRESS_FULL_MESSAGE_POLICY
                  .resolveModelAttribute(context, config)
                  .asString());
      settings.setAddressFullMessagePolicy(addressPolicy);
    }
    if (config.hasDefined(DEAD_LETTER_ADDRESS.getName())) {
      settings.setDeadLetterAddress(
          asSimpleString(DEAD_LETTER_ADDRESS.resolveModelAttribute(context, config), null));
    }
    if (config.hasDefined(AddressSettingDefinition.LAST_VALUE_QUEUE.getName())) {
      settings.setLastValueQueue(
          AddressSettingDefinition.LAST_VALUE_QUEUE
              .resolveModelAttribute(context, config)
              .asBoolean());
    }
    if (config.hasDefined(AddressSettingDefinition.MAX_DELIVERY_ATTEMPTS.getName())) {
      settings.setMaxDeliveryAttempts(
          AddressSettingDefinition.MAX_DELIVERY_ATTEMPTS
              .resolveModelAttribute(context, config)
              .asInt());
    }
    if (config.hasDefined(AddressSettingDefinition.MAX_SIZE_BYTES.getName())) {
      settings.setMaxSizeBytes(
          AddressSettingDefinition.MAX_SIZE_BYTES.resolveModelAttribute(context, config).asLong());
    }
    if (config.hasDefined(AddressSettingDefinition.MESSAGE_COUNTER_HISTORY_DAY_LIMIT.getName())) {
      settings.setMessageCounterHistoryDayLimit(
          AddressSettingDefinition.MESSAGE_COUNTER_HISTORY_DAY_LIMIT
              .resolveModelAttribute(context, config)
              .asInt());
    }
    if (config.hasDefined(CommonAttributes.EXPIRY_ADDRESS.getName())) {
      settings.setExpiryAddress(
          asSimpleString(EXPIRY_ADDRESS.resolveModelAttribute(context, config), null));
    }
    if (config.hasDefined(AddressSettingDefinition.EXPIRY_DELAY.getName())) {
      settings.setExpiryDelay(
          AddressSettingDefinition.EXPIRY_DELAY.resolveModelAttribute(context, config).asLong());
    }
    if (config.hasDefined(AddressSettingDefinition.REDELIVERY_DELAY.getName())) {
      settings.setRedeliveryDelay(
          AddressSettingDefinition.REDELIVERY_DELAY
              .resolveModelAttribute(context, config)
              .asLong());
    }
    if (config.hasDefined(AddressSettingDefinition.REDELIVERY_MULTIPLIER.getName())) {
      settings.setRedeliveryMultiplier(
          AddressSettingDefinition.REDELIVERY_MULTIPLIER
              .resolveModelAttribute(context, config)
              .asDouble());
    }
    if (config.hasDefined(AddressSettingDefinition.MAX_REDELIVERY_DELAY.getName())) {
      settings.setMaxRedeliveryDelay(
          AddressSettingDefinition.MAX_REDELIVERY_DELAY
              .resolveModelAttribute(context, config)
              .asLong());
    }
    if (config.hasDefined(AddressSettingDefinition.REDISTRIBUTION_DELAY.getName())) {
      settings.setRedistributionDelay(
          AddressSettingDefinition.REDISTRIBUTION_DELAY
              .resolveModelAttribute(context, config)
              .asLong());
    }
    if (config.hasDefined(AddressSettingDefinition.PAGE_SIZE_BYTES.getName())) {
      settings.setPageSizeBytes(
          AddressSettingDefinition.PAGE_SIZE_BYTES.resolveModelAttribute(context, config).asLong());
    }
    if (config.hasDefined(AddressSettingDefinition.PAGE_MAX_CACHE_SIZE.getName())) {
      settings.setPageCacheMaxSize(
          AddressSettingDefinition.PAGE_MAX_CACHE_SIZE
              .resolveModelAttribute(context, config)
              .asInt());
    }
    if (config.hasDefined(AddressSettingDefinition.SEND_TO_DLA_ON_NO_ROUTE.getName())) {
      settings.setSendToDLAOnNoRoute(
          AddressSettingDefinition.SEND_TO_DLA_ON_NO_ROUTE
              .resolveModelAttribute(context, config)
              .asBoolean());
    }
    return settings;
  }
Exemplo n.º 4
0
  @Test
  public void testGetNumberOfPages() throws Exception {
    session.close();
    server.stop();
    server.getConfiguration().setPersistenceEnabled(true);

    SimpleString address = RandomUtil.randomSimpleString();

    AddressSettings addressSettings = new AddressSettings();
    addressSettings.setPageSizeBytes(1024);
    addressSettings.setMaxSizeBytes(10 * 1024);
    final int NUMBER_MESSAGES_BEFORE_PAGING = 5;

    server.getAddressSettingsRepository().addMatch(address.toString(), addressSettings);
    server.start();
    ServerLocator locator2 =
        HornetQClient.createServerLocatorWithoutHA(
            new TransportConfiguration(UnitTestCase.INVM_CONNECTOR_FACTORY));
    addServerLocator(locator2);
    ClientSessionFactory sf2 = createSessionFactory(locator2);

    session = sf2.createSession(false, true, false);
    session.start();
    session.createQueue(address, address, true);

    QueueImpl serverQueue = (QueueImpl) server.locateQueue(address);

    ClientProducer producer = session.createProducer(address);

    for (int i = 0; i < NUMBER_MESSAGES_BEFORE_PAGING; i++) {
      ClientMessage msg = session.createMessage(true);
      msg.getBodyBuffer().writeBytes(new byte[512]);
      producer.send(msg);
    }
    session.commit();

    AddressControl addressControl = createManagementControl(address);
    Assert.assertEquals(0, addressControl.getNumberOfPages());

    ClientMessage msg = session.createMessage(true);
    msg.getBodyBuffer().writeBytes(new byte[512]);
    producer.send(msg);

    session.commit();
    Assert.assertEquals(1, addressControl.getNumberOfPages());

    msg = session.createMessage(true);
    msg.getBodyBuffer().writeBytes(new byte[512]);
    producer.send(msg);

    session.commit();
    Assert.assertEquals(1, addressControl.getNumberOfPages());

    msg = session.createMessage(true);
    msg.getBodyBuffer().writeBytes(new byte[512]);
    producer.send(msg);

    session.commit();

    Assert.assertEquals("# of pages is 2", 2, addressControl.getNumberOfPages());

    System.out.println("Address size=" + addressControl.getAddressSize());

    Assert.assertEquals(
        serverQueue.getPageSubscription().getPagingStore().getAddressSize(),
        addressControl.getAddressSize());
  }
  public void contextInitialized(Injector injector) {
    org.candlepin.common.config.Configuration candlepinConfig =
        injector.getInstance(org.candlepin.common.config.Configuration.class);

    if (hornetqServer == null) {
      Configuration config = new ConfigurationImpl();

      HashSet<TransportConfiguration> transports = new HashSet<TransportConfiguration>();
      transports.add(new TransportConfiguration(InVMAcceptorFactory.class.getName()));
      config.setAcceptorConfigurations(transports);

      // alter the default pass to silence log output
      config.setClusterUser(null);
      config.setClusterPassword(null);

      // in vm, who needs security?
      config.setSecurityEnabled(false);

      config.setJournalType(JournalType.NIO);

      config.setCreateBindingsDir(true);
      config.setCreateJournalDir(true);

      String baseDir = candlepinConfig.getString(ConfigProperties.HORNETQ_BASE_DIR);

      config.setBindingsDirectory(new File(baseDir, "bindings").toString());
      config.setJournalDirectory(new File(baseDir, "journal").toString());
      config.setLargeMessagesDirectory(new File(baseDir, "largemsgs").toString());
      config.setPagingDirectory(new File(baseDir, "paging").toString());

      Map<String, AddressSettings> settings = new HashMap<String, AddressSettings>();
      AddressSettings pagingConfig = new AddressSettings();

      String addressPolicyString =
          candlepinConfig.getString(ConfigProperties.HORNETQ_ADDRESS_FULL_POLICY);
      long maxQueueSizeInMb = candlepinConfig.getInt(ConfigProperties.HORNETQ_MAX_QUEUE_SIZE);
      long maxPageSizeInMb = candlepinConfig.getInt(ConfigProperties.HORNETQ_MAX_PAGE_SIZE);

      AddressFullMessagePolicy addressPolicy = null;
      if (addressPolicyString.equals("PAGE")) {
        addressPolicy = AddressFullMessagePolicy.PAGE;
      } else if (addressPolicyString.equals("BLOCK")) {
        addressPolicy = AddressFullMessagePolicy.BLOCK;
      } else {
        throw new IllegalArgumentException(
            "Unknown HORNETQ_ADDRESS_FULL_POLICY: "
                + addressPolicyString
                + " . Please use one of: PAGE, BLOCK");
      }

      // Paging sizes need to be converted to bytes
      pagingConfig.setMaxSizeBytes(maxQueueSizeInMb * FileUtils.ONE_MB);
      if (addressPolicy == AddressFullMessagePolicy.PAGE) {
        pagingConfig.setPageSizeBytes(maxPageSizeInMb * FileUtils.ONE_MB);
      }
      pagingConfig.setAddressFullMessagePolicy(addressPolicy);
      // Enable for all the queues
      settings.put("#", pagingConfig);
      config.setAddressesSettings(settings);

      int maxScheduledThreads =
          candlepinConfig.getInt(ConfigProperties.HORNETQ_MAX_SCHEDULED_THREADS);
      int maxThreads = candlepinConfig.getInt(ConfigProperties.HORNETQ_MAX_THREADS);
      if (maxThreads != -1) {
        config.setThreadPoolMaxSize(maxThreads);
      }

      if (maxScheduledThreads != -1) {
        config.setScheduledThreadPoolMaxSize(maxScheduledThreads);
      }

      /**
       * Anything up to size of LARGE_MSG_SIZE may be needed to be written to the Journal, so we
       * must set buffer size accordingly.
       *
       * <p>If buffer size would be < LARGE_MSG_SIZE we may get exceptions such as this: Can't write
       * records bigger than the bufferSize(XXXYYY) on the journal
       */
      int largeMsgSize = candlepinConfig.getInt(ConfigProperties.HORNETQ_LARGE_MSG_SIZE);
      config.setJournalBufferSize_AIO(largeMsgSize);
      config.setJournalBufferSize_NIO(largeMsgSize);

      hornetqServer = new EmbeddedHornetQ();
      hornetqServer.setConfiguration(config);
    }
    try {
      hornetqServer.start();
      log.info("Hornetq server started");
    } catch (Exception e) {
      log.error("Failed to start hornetq message server:", e);
      throw new RuntimeException(e);
    }

    setupAmqp(injector, candlepinConfig);
    cleanupOldQueues();

    List<String> listeners = getHornetqListeners(candlepinConfig);

    eventSource = injector.getInstance(EventSource.class);
    for (int i = 0; i < listeners.size(); i++) {
      try {
        Class<?> clazz = this.getClass().getClassLoader().loadClass(listeners.get(i));
        eventSource.registerListener((EventListener) injector.getInstance(clazz));
      } catch (Exception e) {
        log.warn("Unable to register listener " + listeners.get(i), e);
      }
    }

    // Initialize the Event sink AFTER the internal server has been
    // created and started.
    EventSink sink = injector.getInstance(EventSink.class);
    try {
      sink.initialize();
    } catch (Exception e) {
      log.error("Failed to initialize EventSink:", e);
      throw new RuntimeException(e);
    }
  }