Core benchmark code.
Connect. Initialize. Run the loop. Cleanup. Print Results.

@throws InterruptedException
@throws IOException
@throws NoConnectionsException
@throws ProcCallException
330257
public void run() throws InterruptedException, NoConnectionsException, IOException, ProcCallException {
        System.out.print(HORIZONTAL_RULE);
        System.out.println(" Setup & Initialization");
        System.out.println(HORIZONTAL_RULE);

        // connect to one or more servers, loop until success
        connect(config.servers);

        System.out.print(HORIZONTAL_RULE);
        System.out.println(" Starting Benchmark");
        System.out.println(HORIZONTAL_RULE);

        // Run the benchmark loop for the requested warmup time
        // The throughput may be throttled depending on client configuration
        System.out.println("Warming up...");
        final long warmupEndTime = System.currentTimeMillis() + (1000l * config.warmup);

        long now = System.currentTimeMillis();
        while (warmupEndTime > now) {
            CallEvent call = networkTransformer.next(now);
            if (call == null) {
                try { Thread.sleep(1); } catch (InterruptedException e) {}
            }
            else {
                sendEvent(call);
            }
            now = System.currentTimeMillis();
        }

        // reset the stats after warmup
        fullStatsContext.fetchAndResetBaseline();
        periodicStatsContext.fetchAndResetBaseline();

        // print periodic statistics to the console
        benchmarkStartTS = System.currentTimeMillis();
        schedulePeriodicStats();

        // Run the benchmark loop for the requested duration
        // The throughput may be throttled depending on client configuration
        System.out.println("\nRunning benchmark...");
        final long benchmarkEndTime = System.currentTimeMillis() + (1000l * config.duration);

        now = System.currentTimeMillis();
        while (benchmarkEndTime > now) {
            CallEvent call = networkTransformer.next(now);
            if (call == null) {
                try { Thread.sleep(1); } catch (InterruptedException e) {}
            }
            else {
                sendEvent(call);
            }
            now = System.currentTimeMillis();
        }

        // cancel periodic stats printing
        timer.cancel();

        // drain any messages that are waiting to be sent immediately
        CallEvent call = null;
        while ((call = networkTransformer.drain()) != null) {
            sendEvent(call);
        }

        // block until all outstanding txns return
        client.drain();

        // print out some debugging stats
        callSimulator.printSummary();

        // print the summary results
        printResults();

        // close down the client connections
        client.close();
    }
305450
@Override
    public void run() {
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        subjectRepository.getSubjectsCollection(new SubjectRepository.SubjectListCallback() {
            @Override
            public void onSubjectListLoader(final Collection<Subject> subjects) {
                mainThread.post(new Runnable() {
                    @Override
                    public void run() {
                        callback.onSubjectListLoaded(subjects);
                    }
                });
            }

            @Override
            public void onError(final SubjectException exception) {
                mainThread.post(new Runnable() {
                    @Override
                    public void run() {
                        callback.onError(exception);
                        Log.i(getClass().toString(), "Error!");
                    }
                });
            }
        });
    }
466107
@Override
  public void run(Context context) throws IOException, InterruptedException {
    outer = context;
    int numberOfThreads = getNumberOfThreads(context);
    mapClass = getMapperClass(context);
    if (LOG.isDebugEnabled()) {
      LOG.debug("Configuring multithread runner to use " + numberOfThreads + 
                " threads");
    }
    
    runners =  new ArrayList<MapRunner>(numberOfThreads);
    for(int i=0; i < numberOfThreads; ++i) {
      MapRunner thread = new MapRunner(context);
      thread.start();
      runners.add(i, thread);
    }
    for(int i=0; i < numberOfThreads; ++i) {
      MapRunner thread = runners.get(i);
      thread.join();
      Throwable th = thread.throwable;
      if (th != null) {
        if (th instanceof IOException) {
          throw (IOException) th;
        } else if (th instanceof InterruptedException) {
          throw (InterruptedException) th;
        } else {
          throw new RuntimeException(th);
        }
      }
    }
  }
1218385
public synchronized void start() throws Exception {
        if (running) {
            return;
        }
        
        List<Connector> startedConnectors = new ArrayList<Connector>();
        for (Connector each : this.connectors) {
            try {
                each.setServer( this );
                each.start();
                startedConnectors.add( each );
            } catch (Exception e) {
                for (Connector stop : startedConnectors) {
                    try {
                        stop.stop();
                    } catch (Exception e2) {

                    }
                }
                throw e;
            }
        }
        running = true;
    }
44143
public void run()
        {
            outer:
            while (run || !queue.isEmpty())
            {
                List<ByteBuffer> bindVariables;
                try
                {
                    bindVariables = queue.take();
                }
                catch (InterruptedException e)
                {
                    // re-check loop condition after interrupt
                    continue;
                }

                Iterator<InetAddress> iter = endpoints.iterator();
                while (true)
                {
                    // send the mutation to the last-used endpoint.  first time through, this will NPE harmlessly.
                    try
                    {
                        int i = 0;
                        int itemId = preparedStatement(client);
                        while (bindVariables != null)
                        {
                            client.execute_prepared_cql3_query(itemId, bindVariables, ConsistencyLevel.ONE);
                            i++;
                            
                            if (i >= batchThreshold)
                                break;
                            
                            bindVariables = queue.poll();
                        }
                        
                        break;
                    }
                    catch (Exception e)
                    {
                        closeInternal();
                        if (!iter.hasNext())
                        {
                            lastException = new IOException(e);
                            break outer;
                        }
                    }

                    // attempt to connect to a different endpoint
                    try
                    {
                        InetAddress address = iter.next();
                        String host = address.getHostName();
                        int port = ConfigHelper.getOutputRpcPort(conf);
                        client = CqlOutputFormat.createAuthenticatedClient(host, port, conf);
                    }
                    catch (Exception e)
                    {
                        closeInternal();
                        // TException means something unexpected went wrong to that endpoint, so
                        // we should try again to another.  Other exceptions (auth or invalid request) are fatal.
                        if ((!(e instanceof TException)) || !iter.hasNext())
                        {
                            lastException = new IOException(e);
                            break outer;
                        }
                    }
                }
            }

            // close all our connections once we are done.
            closeInternal();
        }
1264594
@Override
    public void run(SiteProcedureConnection siteConnection)
    {
        final String threadName = Thread.currentThread().getName(); // Thread name has to be materialized here
        final VoltTrace.TraceEventBatch traceLog = VoltTrace.log(VoltTrace.Category.MPSITE);
        if (traceLog != null) {
            traceLog.add(() -> VoltTrace.meta("thread_name", "name", threadName))
                    .add(() -> VoltTrace.meta("thread_sort_index", "sort_index", Integer.toString(1000)))
                    .add(() -> VoltTrace.beginDuration("mpinittask",
                                                       "txnId", TxnEgo.txnIdToString(getTxnId())));
        }

        // Cast up. Could avoid ugliness with Iv2TransactionClass baseclass
        MpTransactionState txn = (MpTransactionState)m_txnState;
        // Check for restarting sysprocs
        String spName = txn.m_initiationMsg.getStoredProcedureName();
        // could be null if not a sysproc
        final SystemProcedureCatalog.Config sysproc = SystemProcedureCatalog.listing.get(spName);

        // certain system procs can and can't be restarted
        // Right now this is adhoc, catalog update, load MP table, and apply binary log MP.
        //
        // Note that we don't restart @BalancePartitions transactions, because they do
        // partition to master HSID lookups in the run() method. When transactions are
        // restarted, the run() method is not rerun. Let the elastic join coordinator reissue it.
        if (m_isRestart &&
                sysproc != null &&
                !sysproc.isRestartable())
        {
            InitiateResponseMessage errorResp = new InitiateResponseMessage(txn.m_initiationMsg);
            errorResp.setResults(new ClientResponseImpl(ClientResponse.UNEXPECTED_FAILURE,
                        new VoltTable[] {},
                        "Failure while running system procedure " + txn.m_initiationMsg.getStoredProcedureName() +
                        ", and system procedures can not be restarted."));
            errorResp.m_isFromNonRestartableSysproc = true;
            errorResp.m_sourceHSId = m_initiator.getHSId();
            m_txnState.setDone();
            m_queue.flush(getTxnId());
            m_initiator.deliver(errorResp);

            if (hostLog.isDebugEnabled()) {
                hostLog.debug("SYSPROCFAIL: " + this);
            }
            return;
        }

        // Let's ensure that we flush any previous attempts of this transaction
        // at the masters we're going to try to use this time around.
        if (m_isRestart) {
            CompleteTransactionMessage restart = new CompleteTransactionMessage(
                    m_initiator.getHSId(), // who is the "initiator" now??
                    m_initiator.getHSId(),
                    m_txnState.txnId,
                    m_txnState.isReadOnly(),
                    0,
                    true,   // rollback
                    false,  // really don't want to have ack the ack.
                    true,   // Don't clear/flush the txn because we are restarting it
                    m_msg.isForReplay(),
                    txn.isNPartTxn(),
                    false,
                    false);
            // TransactionTaskQueue uses it to find matching CompleteTransactionMessage
            long ts = m_restartSeqGenerator.getNextSeqNum();
            restart.setTimestamp(ts);
            // Update the timestamp to txnState so following restarted fragments could use it
            m_txnState.setTimestamp(ts);
            restart.setTruncationHandle(m_msg.getTruncationHandle());
            //restart.setForReplica(false);
            if (hostLog.isDebugEnabled()) {
                hostLog.debug("MP restart cleanup CompleteTransactionMessage "+ MpRestartSequenceGenerator.restartSeqIdToString(ts) +
                        " to: " + CoreUtils.hsIdCollectionToString(m_initiatorHSIds));
            }
            m_initiator.send(com.google_voltpatches.common.primitives.Longs.toArray(m_initiatorHSIds), restart);
        }
        if (hostLog.isDebugEnabled()) {
            hostLog.debug("[MpProcedureTask] STARTING: " + this);
        }
        final InitiateResponseMessage response = processInitiateTask(txn.m_initiationMsg, siteConnection);
        // We currently don't want to restart read-only MP transactions because:
        // 1) We're not writing the Iv2InitiateTaskMessage to the first
        // FragmentTaskMessage in read-only case in the name of some unmeasured
        // performance impact,
        // 2) We don't want to perturb command logging and/or DR this close to the 3.0 release
        // 3) We don't guarantee the restarted results returned to the client
        // anyway, so not restarting the read is currently harmless.
        // We could actually restart this here, since we have the invocation, but let's be consistent?
        int status = response.getClientResponseData().getStatus();
        if (status == ClientResponse.TXN_MISROUTED) {
            if (m_msg.isReadOnly()) {
                if (!response.shouldCommit()) {
                    txn.setNeedsRollback(true);
                }
                completeInitiateTask(siteConnection);
                response.m_sourceHSId = m_initiator.getHSId();
                response.setMisrouted(m_msg.getStoredProcedureInvocation());
                m_initiator.deliver(response);
            } else {
                restartTransaction();
            }
            if (hostLog.isDebugEnabled()) {
                hostLog.debug("[MpProcedureTask] MISROUTED-RESTART: " + this);
            }
        } else {
            if (status != ClientResponse.TXN_RESTART || (status == ClientResponse.TXN_RESTART && m_msg.isReadOnly())) {
                if (!response.shouldCommit()) {
                    txn.setNeedsRollback(true);
                }
                else {
                    // rollback responses won't advance the truncation point so skip the update
                    response.setMpFragmentSent(txn.haveSentFragment());
                }
                completeInitiateTask(siteConnection);
                // Set the source HSId (ugh) to ourselves so we track the message path correctly
                response.m_sourceHSId = m_initiator.getHSId();
                m_initiator.deliver(response);
                execLog.l7dlog( Level.TRACE, LogKeys.org_voltdb_ExecutionSite_SendingCompletedWUToDtxn.name(), null);
                if (hostLog.isDebugEnabled()) {
                    hostLog.debug("[MpProcedureTask] COMPLETE: " + this);
                }
            } else {
                restartTransaction();
                if (hostLog.isDebugEnabled()) {
                    hostLog.debug("[MpProcedureTask] RESTART: " + this);
                }
            }
        }

        if (traceLog != null) {
            traceLog.add(VoltTrace::endDuration);
        }
    }
1000006
public void run() {
      /**
        * Ensure we start fresh.
        */
    getLogger().debug("performing socket cleanup prior to entering loop for {}",  name);
    closeServerSocket();
    closeAllAcceptedSockets();
    getLogger().debug("socket cleanup complete for {}", name);       
    active = true;

    // start the server socket
    try {
      serverSocket = new ServerSocket(port);
    } catch (Exception e) {
      getLogger().error(
        "error starting SocketReceiver (" + this.getName()
        + "), receiver did not start", e);
      active = false;
      doShutdown();

      return;
    }

    Socket socket = null;

    try {
      getLogger().debug("in run-about to enter while isactiveloop");

      active = true;

      while (!rThread.isInterrupted()) {
        // if we have a socket, start watching it
        if (socket != null) {
          getLogger().debug("socket not null - creating and starting socketnode");
          socketList.add(socket);

          XMLSocketNode node = new XMLSocketNode(decoder, socket, this);
          node.setLoggerRepository(this.repository);
          new Thread(node).start();
          socket = null;
        }

        getLogger().debug("waiting to accept socket");

        // wait for a socket to open, then loop to start it
        socket = serverSocket.accept();
        getLogger().debug("accepted socket");
      }

      // socket not watched because we a no longer running
      // so close it now.
      if (socket != null) {
        socket.close();
      }
    } catch (Exception e) {
      getLogger().warn(
        "socket server disconnected, stopping");
    }
  }
810876
public void startSynchronization() throws IOException, ServiceException,
            AuthenticationException, NotFoundException, RedmineException, ParseException {

        // retrieve new issues
        final List<EditableAcraReport> listReports = retrieveUnsyncedElements();

        // update Chiliproject
        for (final EditableAcraReport report : listReports) {

            final Issue issue = getIssueForStack(report.getStacktraceMD5());

            try {
                if (null == issue) {
                    LOGGER.debug("Got a new bugreport: reportId={}", report.getId());
                    for (final AcraReportHandler handler : reportHandlers) {
                        handler.onNewReport(report);
                    }
                } else if (ChiliprojectUtils.isSynchronized(report, issue)) {
                    LOGGER.debug("Got a bugreport already synchronized: reportId={}",
                            report.getId());
                    for (final AcraReportHandler handler : reportHandlers) {
                        handler.onKnownIssueAlreadySynchronized(report, issue);
                    }
                } else {
                    LOGGER.debug(
                            "Got a new bugreport with a stacktrace similar to an existing ticket: reportId={}",
                            report.getId());
                    for (final AcraReportHandler handler : reportHandlers) {
                        handler.onKnownIssueNotSynchronized(report, issue);
                    }
                }
            } catch (final SynchronizationException e) {
                report.mergeSyncStatus(SyncStatus.FAILURE);
                LOGGER.error("Unable to synchronize ACRA report " + report.getId(), e);
            }
        }

        try {
            for (final AcraReportHandler handler : reportHandlers) {
                handler.onFinishReceivingNewReports();
            }
        } catch (final SynchronizationException e) {
            for (final EditableAcraReport report : listReports) {
                report.mergeSyncStatus(SyncStatus.FAILURE);
            }
            LOGGER.error("Unable to finalize ACRA report synchronization");
        }

        // update/set stack_trace_md5 cells
        for (final EditableAcraReport report : listReports) {
            if (SyncStatus.SUCCESS.equals(report.getStatus())) {
                report.commitStacktraceMD5();
            }
        }
    }
1086472
@Override
  @SuppressWarnings("unchecked")
  public void run() {
    while (!this.shutdown) {
      try {
        this.lastThreadCheckTime = System.currentTimeMillis();
        this.updater.updateExecutions();
        // TODO not sure why it would be important to check the status immediately in case of _new_
        // executions. This can only optimize finalizing executions that finish super-quickly after
        // being started.
        waitForNewExecutions();
      } catch (final Exception e) {
        logger.error("Unexpected exception in updating executions", e);
      }
    }
  }
744073
private void init() {
        assertUnlocked();
        
        lock.lock();
        try {
            httpSender.init(cfg);

            LOG.info(
                "Starting with "
                    + DEFAULT_REQ_PROC_COUNT + " request processors");

            procThreads = new RequestProcessor[DEFAULT_REQ_PROC_COUNT];

            for (int i = 0; i < procThreads.length; i++) {
                procThreads[i] = new RequestProcessor(i);
                procThreads[i].start();
            }

        } finally {
            lock.unlock();
        }
    }
724162
public void process( FastQueue<TldRegion> regions , FastQueue<TldRegion> output ) {

		final int N = regions.size;

		// set all connections to be a local maximum initially
		conn.growArray(N);
		for( int i = 0; i < N; i++ ) {
			conn.data[i].reset();
		}

		// Create the graph of connected regions and mark which regions are local maximums
		for( int i = 0; i < N; i++ ) {
			TldRegion ra = regions.get(i);
			Connections ca = conn.data[i];

			for( int j = i+1; j < N; j++ ) {
				TldRegion rb = regions.get(j);
				Connections cb = conn.data[j];

				// see if they are connected
				double overlap = helper.computeOverlap(ra.rect,rb.rect);
				if( overlap < connectionThreshold ) {
					continue;
				}

				// connect the two and check for strict maximums
				ca.maximum &= ra.confidence > rb.confidence;
				cb.maximum &= rb.confidence > ra.confidence;
				ra.connections++;
				rb.connections++;
			}
		}

		// Compute the output from local maximums.
		for( int i = 0; i < N; i++ ) {
			TldRegion ra = regions.get(i);
			Connections ca = conn.data[i];

			if( ca.maximum ) {
				TldRegion o = output.grow();
				o.connections = ra.connections;
				o.confidence = ra.confidence;
				o.rect.set(ra.rect);
			} else if( ra.connections == 0 ) {
				System.out.println("Not a maximum but has zero connections?");
			}
		}
	}
837053
public void run() {
    try {
      startCleanupThreads();
      try {
        // This while-loop attempts reconnects if we get network errors
        while (running && !shuttingDown) {
          try {
            State osState = offerService();
            if (osState == State.STALE || osState == State.DENIED) {
              // Shutdown TaskTracker instead of reinitialize.
              // TaskTracker should be restarted by external tools.
              LOG.error("offerService returns " + osState + ". Shutdown. ");
              break;
            }
          } catch (Exception ex) {
            if (!shuttingDown) {
              LOG.info("Lost connection to JobTracker [" +
                  jobTrackAddr + "].  Retrying...", ex);
              try {
                Thread.sleep(5000);
              } catch (InterruptedException ie) {
              }
            }
          }
        }
      } finally {
        shutdown();
      }
    } catch (IOException iex) {
      LOG.error("Got fatal exception while initializing TaskTracker", iex);
      return;
    }
  }
911326
public void runBenchmark() throws Exception {
        System.out.print(HORIZONTAL_RULE);
        System.out.println(" Setup & Initialization");
        System.out.println(HORIZONTAL_RULE);

        // connect to one or more servers, loop until success
        connect(m_client, m_config.servers);

        System.out.print("\n\n" + HORIZONTAL_RULE);
        System.out.println(" Starting Benchmark");
        System.out.println(HORIZONTAL_RULE);

        System.out.println("\nStarting bid generator\n");
        BidGenerator bidGenerator = new BidGenerator(m_client);
        long usDelay = (long) ((1.0 / BID_FREQUENCY_PER_SECOND) * 1000000.0);
        m_scheduler.scheduleWithFixedDelay(bidGenerator, 0, usDelay, TimeUnit.MICROSECONDS);

        System.out.println("\nStarting nibble deleter to delete expired data\n");
        NibbleDeleter deleter = new NibbleDeleter(m_client, m_config.displayinterval + 1);
        // Run once a second
        m_scheduler.scheduleWithFixedDelay(deleter, 1, 1, TimeUnit.SECONDS);

        System.out.println("\nWarming up...");
        final long warmupEndTime = System.currentTimeMillis() + (1000l * m_config.warmup);
        while (warmupEndTime > System.currentTimeMillis()) {
            requestAd();
        }

        // reset the stats
        m_fullStatsContext.fetchAndResetBaseline();
        m_periodicStatsContext.fetchAndResetBaseline();

        // print periodic statistics to the console
        m_benchmarkStartTS = System.currentTimeMillis();
        schedulePeriodicStats();

        // Run the benchmark loop for the requested duration
        // The throughput may be throttled depending on client configuration
        System.out.println("\nRunning benchmark...");
        final long benchmarkEndTime = System.currentTimeMillis() + (1000l * m_config.duration);
        while (benchmarkEndTime > System.currentTimeMillis()) {
            requestAd();
        }

        printResults();
        shutdown();
    }
814207
public void start() throws Throwable
   {
      if (!isExternal)
      {
         executorService = Executors.newSingleThreadExecutor(new IdleThreadFactory());
      }

      shutdown.set(false);
      interval = Long.MAX_VALUE;
      next = Long.MAX_VALUE;

      executorService.execute(new IdleConnectionRemoverRunner());
   }
1122453
private void loadLoop() throws InterruptedException {
        boolean firstItem = true;
        boolean moreAvailable = true;

        // Loop until all loaded.
        while (moreAvailable) {
            // Thread interruptions terminate the loop.
            if (currentThread().isInterrupted()) {
                throw new InterruptedException();
            }
            try {
                setLoading(true);

                // Load next increment of items.
                final Result<? extends T> result = load();
                moreAvailable = result != null && result.getRemaining() > 0;
                setAvailable(result != null ? result.getRemaining() : 0);

                // If invalidated while shown, we lazily clear the data so the user doesn't see blank data while loading.
                final boolean needToClear = firstItem;
                firstItem = false;
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        List<? extends T> elements =
                                result != null ? result.getElements() : Collections.<T>emptyList();
                        if (needToClear) {
                            overwriteResult(elements);
                        } else {
                            appendResult(elements);
                        }
                        setLoading(false);
                    }
                });
            } catch (InterruptedException e) {
                throw e;
            } catch (InterruptedIOException e) {
                InterruptedException interruptedException = new InterruptedException();
                interruptedException.initCause(e);
                throw interruptedException;
            } catch (final Throwable e) {
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        notifyError(e);
                    }
                });
                mError = true;
                setLoading(false);
            }

            // Block until instructed to continue, even if an error occurred.
            // In this case, loading must be explicitly resumed.
            block();
        }
    }
1005969
@Override
  public void run() {
    try {
      startCleanupThreads();
      try {
        while (running && !shuttingDown) {
          try {
            heartbeatToClusterManager();
          } catch (IOException e) {
            LOG.error("Error initializing heartbeat to Cluster Manager", e);
            try {
              Thread.sleep(5000L);
            } catch (InterruptedException ie) {
            }
          }
          if (shuttingDown) {
            return;
          }
        }
      } finally {
        shutdown();
      }
    } catch (IOException iex) {
      LOG.error("Got fatal exception while initializing TaskTracker", iex);
      return;
    }
  }
967375
@Override
    public void run() {

        // flag for logging in the "final" block
        boolean docOk = false;
        try {

            // create the index document
            m_result = createIndexDocument(m_cms, m_res, m_index, m_count, m_report);
            docOk = true;

            // check if the thread was interrupted
            if (isInterrupted() && LOG.isDebugEnabled()) {
                LOG.debug(
                    Messages.get().getBundle().key(Messages.LOG_ABANDONED_THREAD_FINISHED_1, m_res.getRootPath()));
            }

        } catch (CmsIndexNoContentException e) {
            // Ignore exception caused by empty documents, so that the report is not messed up with error message
            m_report.println(
                org.opencms.report.Messages.get().container(org.opencms.report.Messages.RPT_OK_0),
                I_CmsReport.FORMAT_OK);
        } catch (Throwable exc) {
            if (m_report != null) {
                m_report.println(
                    org.opencms.report.Messages.get().container(org.opencms.report.Messages.RPT_FAILED_0),
                    I_CmsReport.FORMAT_ERROR);
                m_report.println(
                    org.opencms.report.Messages.get().container(
                        org.opencms.report.Messages.RPT_ARGUMENT_1,
                        exc.toString()),
                    I_CmsReport.FORMAT_ERROR);
            }
            if (LOG.isErrorEnabled()) {
                LOG.error(
                    Messages.get().getBundle().key(
                        Messages.ERR_INDEX_RESOURCE_FAILED_2,
                        m_res.getRootPath(),
                        m_index.getName()),
                    exc);
            }
            // set flag to avoid logging in finally block
            docOk = true;
        } finally {
            if (!docOk) {
                // apparently there was a Throwable that causes an issue
                if (m_report != null) {
                    m_report.println(
                        org.opencms.report.Messages.get().container(org.opencms.report.Messages.RPT_FAILED_0),
                        I_CmsReport.FORMAT_ERROR);
                    m_report.println(
                        Messages.get().container(
                            Messages.ERR_INDEX_RESOURCE_FAILED_2,
                            m_res.getRootPath(),
                            m_index.getName()),
                        I_CmsReport.FORMAT_ERROR);
                }
                if (LOG.isErrorEnabled()) {
                    LOG.error(
                        Messages.get().getBundle().key(
                            Messages.ERR_INDEX_RESOURCE_FAILED_2,
                            m_res.getRootPath(),
                            m_index.getName()));
                }
            }
        }
    }