public long[] getTotalUsageInPeriod(Date start_date, Date end_date) {
synchronized (this) {
long[] result = new long[STAT_ENTRY_COUNT];
long start_millis = start_date.getTime();
long end_millis = end_date.getTime();
long now = SystemTime.getCurrentTime();
long now_day = (now / DAY_IN_MILLIS) * DAY_IN_MILLIS;
if (end_millis > now) {
end_millis = now;
}
long start_day = (start_millis / DAY_IN_MILLIS) * DAY_IN_MILLIS;
long end_day = (end_millis / DAY_IN_MILLIS) * DAY_IN_MILLIS;
if (start_day > end_day) {
return (result);
}
long start_offset = start_millis - start_day;
start_offset = start_offset / MIN_IN_MILLIS;
boolean offset_cachable = start_offset % 60 == 0;
System.out.println(
"start="
+ debug_utc_format.format(start_date)
+ ", end="
+ debug_utc_format.format(end_date)
+ ", offset="
+ start_offset);
MonthCache month_cache = null;
for (long this_day = start_day; this_day <= end_day; this_day += DAY_IN_MILLIS) {
String[] bits = utc_date_format.format(new Date(this_day)).split(",");
String year_str = bits[0];
String month_str = bits[1];
String day_str = bits[2];
int year = Integer.parseInt(year_str);
int month = Integer.parseInt(month_str);
int day = Integer.parseInt(day_str);
if (month_cache == null || !month_cache.isForMonth(year_str, month_str)) {
if (month_cache != null && month_cache.isDirty()) {
month_cache.save();
}
month_cache = getMonthCache(year_str, month_str);
}
boolean can_cache =
this_day != now_day
&& (this_day > start_day || (this_day == start_day && offset_cachable))
&& this_day < end_day;
long cache_offset = this_day == start_day ? start_offset : 0;
if (can_cache) {
long[] cached_totals = month_cache.getTotals(day, cache_offset);
if (cached_totals != null) {
for (int i = 0; i < cached_totals.length; i++) {
result[i] += cached_totals[i];
}
continue;
}
} else {
if (this_day == now_day) {
if (day_cache != null) {
if (day_cache.isForDay(year_str, month_str, day_str)) {
long[] cached_totals = day_cache.getTotals(cache_offset);
if (cached_totals != null) {
for (int i = 0; i < cached_totals.length; i++) {
result[i] += cached_totals[i];
}
continue;
}
} else {
day_cache = null;
}
}
}
}
String current_rel_file =
bits[0] + File.separator + bits[1] + File.separator + bits[2] + ".dat";
File stats_file = new File(stats_dir, current_rel_file);
if (!stats_file.exists()) {
if (can_cache) {
month_cache.setTotals(day, cache_offset, new long[0]);
}
} else {
LineNumberReader lnr = null;
try {
System.out.println("Reading " + stats_file);
lnr = new LineNumberReader(new FileReader(stats_file));
long file_start_time = 0;
long[] file_totals = null;
long[] file_result_totals = new long[STAT_ENTRY_COUNT];
long[] session_start_stats = null;
long session_start_time = 0;
long session_time = 0;
while (true) {
String line = lnr.readLine();
if (line == null) {
break;
}
// System.out.println( line );
String[] fields = line.split(",");
if (fields.length < 6) {
continue;
}
String first_field = fields[0];
if (first_field.equals("s")) {
session_start_time = Long.parseLong(fields[2]) * MIN_IN_MILLIS;
if (file_totals == null) {
file_totals = new long[STAT_ENTRY_COUNT];
file_start_time = session_start_time;
}
session_time = session_start_time;
session_start_stats = new long[STAT_ENTRY_COUNT];
for (int i = 3; i < 9; i++) {
session_start_stats[i - 3] = Long.parseLong(fields[i]);
}
} else if (session_start_time > 0) {
session_time += MIN_IN_MILLIS;
int field_offset = 0;
if (first_field.equals("e")) {
field_offset = 3;
}
long[] line_stats = new long[STAT_ENTRY_COUNT];
for (int i = 0; i < 6; i++) {
line_stats[i] = Long.parseLong(fields[i + field_offset]);
file_totals[i] += line_stats[i];
}
if (session_time >= start_millis && session_time <= end_millis) {
for (int i = 0; i < 6; i++) {
result[i] += line_stats[i];
file_result_totals[i] += line_stats[i];
}
}
// System.out.println( getString( line_stats ));
}
}
System.out.println(
"File total: start="
+ debug_utc_format.format(file_start_time)
+ ", end="
+ debug_utc_format.format(session_time)
+ " - "
+ getString(file_totals));
if (can_cache) {
month_cache.setTotals(day, cache_offset, file_result_totals);
if (cache_offset != 0) {
month_cache.setTotals(day, 0, file_totals);
}
} else {
if (this_day == now_day) {
if (day_cache == null) {
System.out.println("Creating day cache");
day_cache = new DayCache(year_str, month_str, day_str);
}
day_cache.setTotals(cache_offset, file_result_totals);
if (cache_offset != 0) {
day_cache.setTotals(0, file_totals);
}
}
}
} catch (Throwable e) {
Debug.out(e);
} finally {
if (lnr != null) {
try {
lnr.close();
} catch (Throwable e) {
}
}
}
}
}
if (month_cache != null && month_cache.isDirty()) {
month_cache.save();
}
System.out.println(" -> " + getString(result));
return (result);
}
}
private void write(int record_type, long[] line_stats) {
synchronized (this) {
try {
final long now = SystemTime.getCurrentTime();
final long now_mins = now / (1000 * 60);
String[] bits = utc_date_format.format(new Date(now)).split(",");
String year = bits[0];
String month = bits[1];
String day = bits[2];
String current_rel_file = year + File.separator + month + File.separator + day + ".dat";
String line;
String stats_str = "";
if (record_type == RT_SESSION_START) {
// absolute values
for (int i = 0; i < line_stats.length; i++) {
stats_str += "," + line_stats[i];
line_stats_prev[i] = 0;
}
day_cache = null;
} else {
// relative values
long[] diffs = new long[STAT_ENTRY_COUNT];
for (int i = 0; i < line_stats.length; i++) {
long diff = line_stats[i] - line_stats_prev[i];
session_total += diff;
diffs[i] = diff;
stats_str += "," + diff;
line_stats_prev[i] = line_stats[i];
stat_averages[i].update(diff);
}
if (day_cache != null) {
if (day_cache.isForDay(year, month, day)) {
day_cache.addRecord(now_mins, diffs);
}
}
}
if (record_type != RT_SESSION_STATS) {
line =
(record_type == RT_SESSION_START ? "s," : "e,")
+ VERSION
+ ","
+ now_mins
+ stats_str;
} else {
line = stats_str.substring(1);
}
if (writer == null || !writer_rel_file.equals(current_rel_file)) {
// first open of a file or file switch
if (writer != null) {
// file switch
if (record_type != RT_SESSION_START) {
writer.println(line);
}
writer.close();
if (writer.checkError()) {
writer = null;
throw (new IOException("Write faled"));
}
writer = null;
}
// no point in opening a new file just to record the session-end
if (record_type != RT_SESSION_END) {
File file = new File(stats_dir, current_rel_file);
file.getParentFile().mkdirs();
writer = new PrintWriter(new FileWriter(file, true));
writer_rel_file = current_rel_file;
if (record_type == RT_SESSION_START) {
writer.println(line);
} else {
// first entry in a new file, files always start with a session-start so they
// can be processed in isolation so reset the session data and start a new one
st_p_sent += line_stats[0];
st_d_sent += line_stats[1];
st_p_received += line_stats[2];
st_d_received += line_stats[3];
st_dht_sent += line_stats[4];
st_dht_received += line_stats[5];
ss_p_sent += line_stats[0];
ss_d_sent += line_stats[1];
ss_p_received += line_stats[2];
ss_d_received += line_stats[3];
ss_dht_sent += line_stats[4];
ss_dht_received += line_stats[5];
stats_str = "";
long[] st_stats =
new long[] {
st_p_sent, st_d_sent, st_p_received, st_d_received, st_dht_sent, st_dht_received
};
for (int i = 0; i < st_stats.length; i++) {
stats_str += "," + st_stats[i];
line_stats_prev[i] = 0;
}
line = "s," + VERSION + "," + now_mins + stats_str;
writer.println(line);
}
}
} else {
writer.println(line);
}
} catch (Throwable e) {
Debug.out("Failed to write long term stats", e);
} finally {
if (writer != null) {
if (record_type == RT_SESSION_END) {
writer.close();
}
if (writer.checkError()) {
Debug.out("Failed to write long term stats");
writer.close();
writer = null;
} else {
if (record_type == RT_SESSION_END) {
writer = null;
}
}
}
}
}
if (record_type != RT_SESSION_END) {
final List<LongTermStatsListener> to_fire = new ArrayList<LongTermStatsListener>();
for (Object[] entry : listeners) {
long diff = session_total - (Long) entry[2];
if (diff >= (Long) entry[1]) {
entry[2] = session_total;
to_fire.add((LongTermStatsListener) entry[0]);
}
}
if (to_fire.size() > 0) {
dispatcher.dispatch(
new AERunnable() {
@Override
public void runSupport() {
for (LongTermStatsListener l : to_fire) {
try {
l.updated(LongTermStatsImpl.this);
} catch (Throwable e) {
Debug.out(e);
}
}
}
});
}
}
}