1 /*******************************************************************************
2 * Copyright (c) 2012 Association for Decentralized Information Management
4 * All rights reserved. This program and the accompanying materials
5 * are made available under the terms of the Eclipse Public License v1.0
6 * which accompanies this distribution, and is available at
7 * http://www.eclipse.org/legal/epl-v10.html
10 * Semantum Oy - initial API and implementation
11 *******************************************************************************/
12 package org.simantics.event.writer;
14 import java.util.ArrayList;
15 import java.util.List;
16 import java.util.concurrent.atomic.AtomicBoolean;
18 import org.eclipse.core.runtime.IProgressMonitor;
19 import org.eclipse.core.runtime.IStatus;
20 import org.eclipse.core.runtime.Status;
21 import org.simantics.DatabaseJob;
22 import org.simantics.Simantics;
23 import org.simantics.db.ReadGraph;
24 import org.simantics.db.Resource;
25 import org.simantics.db.Session;
26 import org.simantics.db.VirtualGraph;
27 import org.simantics.db.WriteOnlyGraph;
28 import org.simantics.db.common.request.UniqueRead;
29 import org.simantics.db.common.request.WriteOnlyRequest;
30 import org.simantics.db.exception.CancelTransactionException;
31 import org.simantics.db.exception.DatabaseException;
32 import org.simantics.db.request.WriteOnly;
33 import org.simantics.event.Activator;
34 import org.simantics.event.util.EventUtils;
35 import org.simantics.event.util.EventWriteData;
38 * A self-scheduling job that queues up {@link EventWriteTask} instances and
39 * periodically executes the queued up tasks in a single graph {@link WriteOnly}
43 * Intended to be constructed and scheduled by experiment implementations.
46 * Must be disposed when no longer used.
48 * @author Tuukka Lehtonen
51 * @see EventSourceResolver
53 public class EventWriterJob extends DatabaseJob {
55 private final boolean DEBUG = false;
57 private static final int WRITE_SCHEDULE_PERIOD = 1000;
59 private static final long MIN_QUEUE_QUIET_TIME = 1000L;
61 private static final long MIN_WRITE_QUIET_TIME = 1000L;
63 private static final int MAX_TASK_QUEUE_SIZE = 500;
65 private static final EventWriteTask[] NONE = {};
67 private List<EventWriteTask> tasks = new ArrayList<EventWriteTask>();
69 private VirtualGraph virtualGraph;
70 private Resource eventLog;
71 private EventSourceResolver resolver;
73 private AtomicBoolean scheduled = new AtomicBoolean(false);
74 private AtomicBoolean polling = new AtomicBoolean(true);
76 private long lastWriteTime = Long.MIN_VALUE;
77 private long lastQueueTime = Long.MIN_VALUE;
79 public EventWriterJob(VirtualGraph virtualGraph, Resource eventLog, EventSourceResolver resolver) {
80 super("Event Writer");
81 setPriority(DECORATE);
84 this.virtualGraph = virtualGraph;
85 this.eventLog = eventLog;
86 this.resolver = resolver;
89 public void dispose() {
91 System.out.println(this + ": DISPOSE");
95 public void queue(EventWriteTask task) {
96 synchronized (tasks) {
98 this.lastQueueTime = System.currentTimeMillis();
100 if (scheduled.compareAndSet(false, true)) {
101 schedule(WRITE_SCHEDULE_PERIOD);
107 public boolean shouldRun() {
108 return polling.get() && Simantics.peekSession() != null;
112 protected IStatus run(final IProgressMonitor monitor) {
114 Session session = Simantics.peekSession();
116 return Status.CANCEL_STATUS;
118 int taskCount = countTasks();
120 return Status.CANCEL_STATUS;
122 long currentTime = System.currentTimeMillis();
124 // Must flush write at some point if no flush has been performed yet.
125 if (lastWriteTime == Long.MIN_VALUE)
126 lastWriteTime = currentTime;
128 long queueQuietTime = currentTime - lastQueueTime;
129 long writeQuietTime = currentTime - lastWriteTime;
130 boolean queueQuietTimePassed = queueQuietTime >= MIN_QUEUE_QUIET_TIME;
131 boolean writeQuietTimePassed = writeQuietTime >= MIN_WRITE_QUIET_TIME;
132 boolean taskCountExceeded = taskCount >= MAX_TASK_QUEUE_SIZE;
135 System.out.println("Queue quiet time: " + queueQuietTime);
136 System.out.println("Write quiet time: " + writeQuietTime);
137 System.out.println("Task count: " + taskCount);
140 if (!writeQuietTimePassed && !queueQuietTimePassed && !taskCountExceeded) {
141 return Status.CANCEL_STATUS;
145 if (queueQuietTimePassed)
146 System.out.println("Queue quiet time (" + MIN_QUEUE_QUIET_TIME + ") exceeded: " + queueQuietTime);
147 if (writeQuietTimePassed)
148 System.out.println("Write quiet time (" + MIN_WRITE_QUIET_TIME + ") exceeded: " + writeQuietTime);
149 if (taskCountExceeded)
150 System.out.println("Maximum queued task count (" + MAX_TASK_QUEUE_SIZE + ") exceeded: " + taskCount);
153 final EventWriteTask[] tasks = pruneTasks();
154 if (tasks.length == 0)
155 return Status.CANCEL_STATUS;
158 System.out.println(this + ": about to write " + tasks.length + " events");
159 setThread(Thread.currentThread());
161 monitor.beginTask("Flush Events", tasks.length);
165 final EventWriteData writeData = session.syncRequest(new UniqueRead<EventWriteData>() {
168 public EventWriteData perform(ReadGraph graph) throws DatabaseException {
169 return new EventWriteData(graph, eventLog, virtualGraph);
174 session.sync(new WriteOnlyRequest(virtualGraph) {
176 public void perform(WriteOnlyGraph graph) throws DatabaseException {
178 setThread(Thread.currentThread());
179 List<Resource> events = new ArrayList<Resource>(tasks.length);
180 for (EventWriteTask task : tasks) {
182 writeData.prepareToWrite(graph);
184 Resource event = task.write(graph, writeData.targetSlice, writeData.targetPos);
193 writeData.commit(graph);
195 if (resolver != null) {
197 System.out.println(EventWriterJob.this + ": queue " + events.size() + " for source resolution");
198 resolver.queueEvents(events);
202 lastWriteTime = System.currentTimeMillis();
203 } catch (CancelTransactionException e) {
205 return Status.CANCEL_STATUS;
206 } catch (DatabaseException e) {
207 return new Status(IStatus.ERROR, Activator.BUNDLE_ID, "Event writing failed", e);
210 return Status.OK_STATUS;
213 schedule(WRITE_SCHEDULE_PERIOD);
217 private int countTasks() {
218 synchronized (tasks) {
223 private EventWriteTask[] pruneTasks() {
224 synchronized (this.tasks) {
225 EventWriteTask[] tasks = this.tasks.toArray(NONE);