/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF 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 org.apache.hadoop.fs.slive;
import java.io.PrintWriter;
import java.text.NumberFormat;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
* Class which provides a report for the given operation output
*/
class ReportWriter {
// simple measurement types
// expect long values
// these will be reported on + rates by this reporter
static final String OK_TIME_TAKEN = "milliseconds_taken";
static final String FAILURES = "failures";
static final String SUCCESSES = "successes";
static final String BYTES_WRITTEN = "bytes_written";
static final String FILES_CREATED = "files_created";
static final String DIR_ENTRIES = "dir_entries";
static final String OP_COUNT = "op_count";
static final String CHUNKS_VERIFIED = "chunks_verified";
static final String CHUNKS_UNVERIFIED = "chunks_unverified";
static final String BYTES_READ = "bytes_read";
static final String NOT_FOUND = "files_not_found";
static final String BAD_FILES = "bad_files";
private static final Log LOG = LogFactory.getLog(ReportWriter.class);
private static final String SECTION_DELIM = "-------------";
/**
* @return String to be used for as a section delimiter
*/
private String getSectionDelimiter() {
return SECTION_DELIM;
}
/**
* Writes a message the the logging library and the given print writer (if it
* is not null)
*
* @param msg
* the message to write
* @param os
* the print writer if specified to also write to
*/
private void writeMessage(String msg, PrintWriter os) {
LOG.info(msg);
if (os != null) {
os.println(msg);
}
}
/**
* Provides a simple report showing only the input size, and for each
* operation the operation type, measurement type and its values.
*
* @param input
* the list of operations to report on
* @param os
* any print writer for which output should be written to (along with
* the logging library)
*/
void basicReport(List<OperationOutput> input, PrintWriter os) {
writeMessage("Default report for " + input.size() + " operations ", os);
writeMessage(getSectionDelimiter(), os);
for (OperationOutput data : input) {
writeMessage("Operation \"" + data.getOperationType() + "\" measuring \""
+ data.getMeasurementType() + "\" = " + data.getValue(), os);
}
writeMessage(getSectionDelimiter(), os);
}
/**
* Provides a more detailed report for a given operation. This will output the
* keys and values for all input and then sort based on measurement type and
* attempt to show rates for various metrics which have expected types to be
* able to measure there rate. Currently this will show rates for bytes
* written, success count, files created, directory entries, op count and
* bytes read if the variable for time taken is available for each measurement
* type.
*
* @param operation
* the operation that is being reported on.
* @param input
* the set of data for that that operation.
* @param os
* any print writer for which output should be written to (along with
* the logging library)
*/
void opReport(String operation, List<OperationOutput> input,
PrintWriter os) {
writeMessage("Basic report for operation type " + operation, os);
writeMessage(getSectionDelimiter(), os);
for (OperationOutput data : input) {
writeMessage("Measurement \"" + data.getMeasurementType() + "\" = "
+ data.getValue(), os);
}
// split up into measurement types for rates...
Map<String, OperationOutput> combined = new TreeMap<String, OperationOutput>();
for (OperationOutput data : input) {
if (combined.containsKey(data.getMeasurementType())) {
OperationOutput curr = combined.get(data.getMeasurementType());
combined.put(data.getMeasurementType(), OperationOutput.merge(curr,
data));
} else {
combined.put(data.getMeasurementType(), data);
}
}
// handle the known types
OperationOutput timeTaken = combined.get(OK_TIME_TAKEN);
if (timeTaken != null) {
Long mTaken = Long.parseLong(timeTaken.getValue().toString());
if (mTaken > 0) {
NumberFormat formatter = Formatter.getDecimalFormatter();
for (String measurementType : combined.keySet()) {
Double rate = null;
String rateType = "";
if (measurementType.equals(BYTES_WRITTEN)) {
Long mbWritten = Long.parseLong(combined.get(measurementType)
.getValue().toString())
/ (Constants.MEGABYTES);
rate = (double) mbWritten / (double) (mTaken / 1000.0d);
rateType = "MB/sec";
} else if (measurementType.equals(SUCCESSES)) {
Long succ = Long.parseLong(combined.get(measurementType).getValue()
.toString());
rate = (double) succ / (double) (mTaken / 1000.0d);
rateType = "successes/sec";
} else if (measurementType.equals(FILES_CREATED)) {
Long filesCreated = Long.parseLong(combined.get(measurementType)
.getValue().toString());
rate = (double) filesCreated / (double) (mTaken / 1000.0d);
rateType = "files created/sec";
} else if (measurementType.equals(DIR_ENTRIES)) {
Long entries = Long.parseLong(combined.get(measurementType)
.getValue().toString());
rate = (double) entries / (double) (mTaken / 1000.0d);
rateType = "directory entries/sec";
} else if (measurementType.equals(OP_COUNT)) {
Long opCount = Long.parseLong(combined.get(measurementType)
.getValue().toString());
rate = (double) opCount / (double) (mTaken / 1000.0d);
rateType = "operations/sec";
} else if (measurementType.equals(BYTES_READ)) {
Long mbRead = Long.parseLong(combined.get(measurementType)
.getValue().toString())
/ (Constants.MEGABYTES);
rate = (double) mbRead / (double) (mTaken / 1000.0d);
rateType = "MB/sec";
}
if (rate != null) {
writeMessage("Rate for measurement \"" + measurementType + "\" = "
+ formatter.format(rate) + " " + rateType, os);
}
}
}
}
writeMessage(getSectionDelimiter(), os);
}
}