/** * Gets the filtered notification tasks from all the post record task list. * * @return the filtered notification tasks */ private List<RecordTask> getFilterNotificationTask() { List<RecordTask> events = new ArrayList<RecordTask>(); for (int i = 0; i < recordList.size(); i++) { ActivityRecord record = recordList.get(i); if (record instanceof AbstractElementRecord) events.addAll(getNotificationTask(record.getPostTasks())); else if (record instanceof CompoundRecord) { // only collect those event will hold till the transaction stack // is empty; otherwise the notifications must already be send CompoundRecord cr = (CompoundRecord) record; if ((cr instanceof FilterEventsCompoundRecord) || (cr instanceof LayoutCompoundRecord)) { if (!((FilterEventsCompoundRecord) cr).isOutermostFilterTrans) events.addAll(cr.getFilterNotificationTask()); } else { TransactionOption options = cr.getOptions(); if (options != null && options.getSendTime() == TransactionOption.OUTMOST_TRANSACTION_SEND_TIME) events.addAll(cr.getFilterNotificationTask()); } } } // filter all the collected events if (options != null) { IEventFilter filter = options.getEventFilter(); if (filter != null) events = filter.filter(events); } return events; }
/** * Checks the state of the contained records. Used in assert statements to validate the compound * record state. * * @param state the state to check. * @return True if all records are in that state, false otherwise. */ private boolean checkState(int state) { Iterator<ActivityRecord> iter = recordList.iterator(); while (iter.hasNext()) { ActivityRecord cmd = iter.next(); if (cmd.getState() != state) return false; } return true; }
public List<ValidationNode> getValidators() { List<ValidationNode> list = new ArrayList<ValidationNode>(); Iterator<ActivityRecord> iter = recordList.iterator(); while (iter.hasNext()) { ActivityRecord record = iter.next(); list.addAll(record.getValidators()); } return list; }
/** * Reports if this record can be redone. A composite record can be redone only if each of the * sub-records can be redone. * * @see ActivityRecord#canRedo() */ public boolean canRedo() { for (Iterator<ActivityRecord> records = recordList.listIterator(); records.hasNext(); ) { ActivityRecord record = records.next(); if (!record.canRedo()) { return false; } } return true; }
protected List<RecordTask> getPostTasks() { List<RecordTask> retList = new ArrayList<RecordTask>(); for (int i = recordList.size() - 1; i >= 0; i--) { ActivityRecord record = recordList.get(i); if (record != null) { retList.addAll(record.getPostTasks()); } } return retList; }
public void rollback() { // Since undo/redo has no information about the transaction stack, // establish a tricky way to restore the information about the // transaction stack. Because filter/layout compound record only // includes filter/layout compound record, records in // <code>recordList</code> only need to know the compound record they // reside in. That is, "this". Stack<CompoundRecord> stack = new Stack<CompoundRecord>(); stack.push(this); for (int i = recordList.size() - 1; i >= 0; i--) { ActivityRecord record = recordList.get(i); if (!record.isPersistent()) { record.rollback(); record.performPostTasks(stack); } } }
/** * Redoes the composite record. This implementation redoes each sub-record in the order they were * originally executed. * * @see ActivityRecord#redo() * @see org.eclipse.birt.report.model.activity.ActivityStack#redo() */ public void redo() { // Since undo/redo has no information about the transaction stack, // establish a tricky way to restore the information about the // transaction stack. Because filter/layout compound record only // includes filter/layout compound record, records in // <code>recordList</code> only need to know the compound record they // reside in. That is, "this". Stack<CompoundRecord> stack = new Stack<CompoundRecord>(); stack.push(this); for (int i = 0; i < recordList.size(); i++) { ActivityRecord record = recordList.get(i); assert record.getState() == ActivityRecord.UNDONE_STATE; record.redo(); record.setState(ActivityRecord.REDONE_STATE); record.performPostTasks(stack); } }
/** Creates an activity record from a text line created by toString() */ public static ActivityRecord parseActivityRecord(String textLine) { ActivityRecord result = null; String[] fields = null; if (textLine != null) { try { // Splits the string fields = textLine.split(FIELDS_REGEXP); // Parses fixed lenght part if (fields.length > 3) { result = new ActivityRecord(); // Parses the date result.date = !fields[0].equals(NULL_STRING) ? new Date(Long.parseLong(fields[0])) : null; // Parses the state result.state = !fields[1].equals(NULL_STRING) ? State.valueOf(fields[1]) : null; // Parses the action result.action = !fields[2].equals(NULL_STRING) ? StateAction.valueOf(fields[2]) : null; // Parses the requested action result.requestedAction = !fields[3].equals(NULL_STRING) ? RequestedAction.valueOf(fields[3]) : null; } // Parses variable length part if (fields.length > 4) { result.payload = new Object[fields.length - 4]; System.arraycopy(fields, 4, result.payload, 0, fields.length - 4); parsePayload(result.payload); } } catch (Exception e) { Log.e(LOGTAG, "Error parsing activity record: " + textLine); Log.e(LOGTAG, Log.getStackTraceString(e)); result = null; } } return result; }
boolean handleAppCrashLocked( ProcessRecord app, String reason, String shortMsg, String longMsg, String stackTrace, AppErrorDialog.Data data) { long now = SystemClock.uptimeMillis(); Long crashTime; Long crashTimePersistent; if (!app.isolated) { crashTime = mProcessCrashTimes.get(app.info.processName, app.uid); crashTimePersistent = mProcessCrashTimesPersistent.get(app.info.processName, app.uid); } else { crashTime = crashTimePersistent = null; } if (crashTime != null && now < crashTime + ProcessList.MIN_CRASH_INTERVAL) { // This process loses! Slog.w(TAG, "Process " + app.info.processName + " has crashed too many times: killing!"); EventLog.writeEvent( EventLogTags.AM_PROCESS_CRASHED_TOO_MUCH, app.userId, app.info.processName, app.uid); mService.mStackSupervisor.handleAppCrashLocked(app); if (!app.persistent) { // We don't want to start this process again until the user // explicitly does so... but for persistent process, we really // need to keep it running. If a persistent process is actually // repeatedly crashing, then badness for everyone. EventLog.writeEvent(EventLogTags.AM_PROC_BAD, app.userId, app.uid, app.info.processName); if (!app.isolated) { // XXX We don't have a way to mark isolated processes // as bad, since they don't have a peristent identity. mBadProcesses.put( app.info.processName, app.uid, new BadProcessInfo(now, shortMsg, longMsg, stackTrace)); mProcessCrashTimes.remove(app.info.processName, app.uid); } app.bad = true; app.removed = true; // Don't let services in this process be restarted and potentially // annoy the user repeatedly. Unless it is persistent, since those // processes run critical code. mService.removeProcessLocked(app, false, false, "crash"); mService.mStackSupervisor.resumeFocusedStackTopActivityLocked(); return false; } mService.mStackSupervisor.resumeFocusedStackTopActivityLocked(); } else { TaskRecord affectedTask = mService.mStackSupervisor.finishTopRunningActivityLocked(app, reason); if (data != null) { data.task = affectedTask; } if (data != null && crashTimePersistent != null && now < crashTimePersistent + ProcessList.MIN_CRASH_INTERVAL) { data.repeating = true; } } // Bump up the crash count of any services currently running in the proc. for (int i = app.services.size() - 1; i >= 0; i--) { // Any services running in the application need to be placed // back in the pending list. ServiceRecord sr = app.services.valueAt(i); sr.crashCount++; } // If the crashing process is what we consider to be the "home process" and it has been // replaced by a third-party app, clear the package preferred activities from packages // with a home activity running in the process to prevent a repeatedly crashing app // from blocking the user to manually clear the list. final ArrayList<ActivityRecord> activities = app.activities; if (app == mService.mHomeProcess && activities.size() > 0 && (mService.mHomeProcess.info.flags & ApplicationInfo.FLAG_SYSTEM) == 0) { for (int activityNdx = activities.size() - 1; activityNdx >= 0; --activityNdx) { final ActivityRecord r = activities.get(activityNdx); if (r.isHomeActivity()) { Log.i(TAG, "Clearing package preferred activities from " + r.packageName); try { ActivityThread.getPackageManager().clearPackagePreferredActivities(r.packageName); } catch (RemoteException c) { // pm is in same process, this will never happen. } } } } if (!app.isolated) { // XXX Can't keep track of crash times for isolated processes, // because they don't have a perisistent identity. mProcessCrashTimes.put(app.info.processName, app.uid, now); mProcessCrashTimesPersistent.put(app.info.processName, app.uid, now); } if (app.crashHandler != null) mService.mHandler.post(app.crashHandler); return true; }
/** * Loads a number of records into cache starting from oldest record of oldest file that has not * been already loaded. */ private boolean loadRecords(int records) { boolean moreRecords = false; boolean moreFiles = false; // Creates the cache if it is not created if (mCache == null) { mCache = new ArrayList<ActivityRecord>(CACHE_PAGE_SIZE); } // Calculates the target maximum size after loading required pages int targetCacheSize = mCache.size() + records; // Gets the file names to iterate, starting in lowest file with records remaining to be loaded Iterator<String> filesIterator = getLogFileNames(mLowestFile, (mLowestRecord != 0)).iterator(); // Reads records until all required pages have been loaded or there are no more files while ((moreFiles = filesIterator.hasNext()) && mCache.size() < targetCacheSize) { // Open next file String fileName; BufferedReader reader = getReader(fileName = filesIterator.next()); if (reader != null) { try { // Read an parse all the records in the current file skipping unformatted lines ArrayList<ActivityRecord> fileBlock = new ArrayList<ActivityRecord>(CACHE_PAGE_SIZE); String line; do { line = reader.readLine(); ActivityRecord record = ActivityRecord.parseActivityRecord(line); if (record != null) { fileBlock.add(record); } } while (line != null); // Initializes record pointers to latest of this file +1 if (mLowestRecord == 0) { mLowestRecord = fileBlock.size(); } // Adds date separator record if (!fileName.equals(mLowestFile)) { mCache.add(new ActivityRecord(getLogFileDate(fileName))); mLowestFile = fileName; } // Calculates the number of records that still have to be added to cache int remSpace = targetCacheSize - mCache.size(); // Extracts the number of records to fill the remaining space moreRecords = mLowestRecord > remSpace; int start = moreRecords ? mLowestRecord - remSpace : 0; int end = mLowestRecord; List<ActivityRecord> subList = fileBlock.subList(start, end); // Adds the records in reverse order at the end of the cache Collections.reverse(subList); mCache.addAll(subList); // Update record pointer mLowestRecord = start; } catch (IOException e) { Log.e(LOGTAG, Log.getStackTraceString(e)); } finally { closeReader(reader); } } } return (mOlderRecords = (moreRecords || moreFiles)); }
@Override public String execute() throws Exception { Connection conn = null; PreparedStatement cStmt = null; String query; try { conn = Constants.DATASOURCE.getConnection(); Long step = (super.cF.getTimeInMillis() - super.cI.getTimeInMillis()) / 1000; step = step / super.spansNumber + (step % super.spansNumber == 0L ? 0 : 1); // round up cI.add(Calendar.SECOND, (int) (start * step)); Calendar c = null; if (limit != null && limit <= super.spansNumber) (c = (Calendar) cI.clone()).add(Calendar.SECOND, (int) (limit * step)); else c = (Calendar) cF.clone(); if (c.before(cF)) cF = c; // CallableStatement cStmt = conn.prepareCall(SqlQuery.SP_RTT_CHART.getSql()); // cStmt.setInt(1, super.idServiceInstance); // cStmt.setTimestamp(2, new Timestamp(super.cI.getTimeInMillis())); // cStmt.setTimestamp(3, new Timestamp(super.cF.getTimeInMillis())); // cStmt.setLong(4, step); table = new ActivityTable(); List<ActivityRecord> records = new LinkedList<ActivityRecord>(); DateFormat formatter = new DateFormat(getLocale().getLanguage()); c = (Calendar) cI.clone(); // boolean hadResults = cStmt.execute(); boolean fullTime = step < 60; if (step > 0) { while (c.getTimeInMillis() < cF.getTimeInMillis()) { query = "SELECT AVG(elapsedTime) as avgRtt FROM esgf_dashboard.service_status WHERE idServiceInstance="; query = query + super.idServiceInstance; query = query + " AND timestamp between '"; query = query + new Timestamp(c.getTimeInMillis()) + "' AND '"; // while(hadResults) { // ResultSet rs = cStmt.getResultSet(); ActivityRecord record = new ActivityRecord(); record.setStartDate(formatter.formatDate(c)); record.setStartTime(formatter.formatTime(c, fullTime)); c.add(Calendar.SECOND, step.intValue()); query = query + new Timestamp(c.getTimeInMillis()) + "'"; // System.out.println("|||->>> RTTTableAction Query = "+query); cStmt = conn.prepareStatement(query); ResultSet rs = cStmt.executeQuery(); record.setEndDate(formatter.formatDate(c)); record.setEndTime(formatter.formatTime(c, fullTime)); record.setValues(new LinkedList<Number>()); if (rs.next() && rs.getBigDecimal("avgRtt") != null) record .getValues() .add(Math.round(rs.getBigDecimal("avgRtt").doubleValue() / 10.) / 100.); else record.getValues().add(null); records.add(record); // hadResults = cStmt.getMoreResults(); } // endwhile } // endif cStmt.close(); table.setActivityRecords(records); table.setTotalCount(super.spansNumber); } catch (SQLException e) { return ERROR; } finally { if (conn != null) conn.close(); } return SUCCESS; }
/** * Appends a record to the compound record. The record must have been executed already. The * application should not call this method directly. Instead, the record should be executed via * the usual call to {@link * org.eclipse.birt.report.model.activity.ActivityStack#execute(org.eclipse.birt.report.model.api.activity.IActivityRecord) * ActivityStack.execute( )}. * * @param record the record to be added. * @see * org.eclipse.birt.report.model.activity.ActivityStack#execute(org.eclipse.birt.report.model.api.activity.IActivityRecord) */ public void append(ActivityRecord record) { assert record != null; assert record.getState() == ActivityRecord.DONE_STATE; recordList.add(record); }