/interpreter/tags/at2dist090708/src/edu/vub/at/actors/natives/ELActor.java

  1/**
  2 * AmbientTalk/2 Project
  3 * ELActor.java created on 27-dec-2006 at 16:17:23
  4 * (c) Programming Technology Lab, 2006 - 2007
  5 * Authors: Tom Van Cutsem & Stijn Mostinckx
  6 * 
  7 * Permission is hereby granted, free of charge, to any person
  8 * obtaining a copy of this software and associated documentation
  9 * files (the "Software"), to deal in the Software without
 10 * restriction, including without limitation the rights to use,
 11 * copy, modify, merge, publish, distribute, sublicense, and/or
 12 * sell copies of the Software, and to permit persons to whom the
 13 * Software is furnished to do so, subject to the following
 14 * conditions:
 15 *
 16 * The above copyright notice and this permission notice shall be
 17 * included in all copies or substantial portions of the Software.
 18 *
 19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 20 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 21 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 22 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 23 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 24 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 25 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 26 * OTHER DEALINGS IN THE SOFTWARE.
 27 */
 28package edu.vub.at.actors.natives;
 29
 30
 31import edu.vub.at.actors.ATActorMirror;
 32import edu.vub.at.actors.ATAsyncMessage;
 33import edu.vub.at.actors.ATFarReference;
 34import edu.vub.at.actors.eventloops.BlockingFuture;
 35import edu.vub.at.actors.eventloops.Callable;
 36import edu.vub.at.actors.eventloops.Event;
 37import edu.vub.at.actors.eventloops.EventLoop;
 38import edu.vub.at.actors.id.ATObjectID;
 39import edu.vub.at.actors.id.ActorID;
 40import edu.vub.at.actors.net.comm.Address;
 41import edu.vub.at.eval.Evaluator;
 42import edu.vub.at.exceptions.InterpreterException;
 43import edu.vub.at.exceptions.XClassNotFound;
 44import edu.vub.at.exceptions.XIOProblem;
 45import edu.vub.at.exceptions.XIllegalOperation;
 46import edu.vub.at.exceptions.XObjectOffline;
 47import edu.vub.at.objects.ATAbstractGrammar;
 48import edu.vub.at.objects.ATMethod;
 49import edu.vub.at.objects.ATObject;
 50import edu.vub.at.objects.ATTable;
 51import edu.vub.at.objects.ATTypeTag;
 52import edu.vub.at.objects.mirrors.Reflection;
 53import edu.vub.at.objects.natives.NATContext;
 54import edu.vub.at.objects.natives.NATObject;
 55import edu.vub.at.objects.natives.NATTable;
 56import edu.vub.at.objects.natives.OBJLexicalRoot;
 57import edu.vub.at.objects.symbiosis.Symbiosis;
 58import edu.vub.at.util.logging.Logging;
 59
 60import java.lang.reflect.Method;
 61import java.util.EventListener;
 62
 63/**
 64 * An instance of the class ELActor represents a programmer-defined
 65 * AmbientTalk/2 actor. The event queue of the actor event loop serves as the
 66 * actor's 'meta-level' queue.
 67 *
 68 * The events in the 'meta-level' queue are handled by the actor's mirror object.
 69 * This mirror is normally an instance of NATActorMirror, but it can be any
 70 * programmer-defined object that adheres to the ATActorMirror interface.
 71 *
 72 * @author tvcutsem
 73 */
 74public class ELActor extends EventLoop {
 75	
 76	/**
 77	 * A thread-local variable that contains the 'default actor' to use
 78	 * when there is currently no ELActor event loop thread running.
 79	 * This is primarily useful for performing unit tests where an actor
 80	 * is automatically created when actor semantics is required.
 81	 * 
 82	 * A warning is printed to the log because using the default actor should
 83	 * only be used for testing purposes.
 84	 */
 85	private static final ThreadLocal _DEFAULT_ACTOR_ = new ThreadLocal() {
 86		protected synchronized Object initialValue() {
 87			Logging.Actor_LOG.warn("Creating a default actor for thread " + Thread.currentThread());
 88			try {
 89				ELVirtualMachine host = new ELVirtualMachine(
 90						Evaluator.getNil(),
 91						new SharedActorField[] { },
 92						ELVirtualMachine._DEFAULT_GROUP_NAME_);
 93				return host.createEmptyActor().getFarHost();
 94			} catch (InterpreterException e) {
 95				throw new RuntimeException("Failed to initialize default actor: " + e.getMessage());
 96			}
 97		}
 98	};
 99	
100	/**
101	 * Retrieves the currently running actor. If there is no running actor thread,
102	 * this returns the value stored in the thread-local default actor field.
103	 */
104	public static final ELActor currentActor() {
105		try {
106			return ((ELActor) EventLoop.currentEventLoop());
107		} catch (ClassCastException e) {
108			// current event loop is not an actor event loop
109		} catch (IllegalStateException e) {
110			// current thread is not an event loop
111		}
112		Logging.Actor_LOG.warn("Asked for an actor in non-actor thread " + Thread.currentThread());
113		return (ELActor) _DEFAULT_ACTOR_.get();
114	}
115
116	private ATActorMirror mirror_;
117	private final ActorID id_;
118	protected final ELVirtualMachine host_;
119	protected final ReceptionistsSet receptionists_;
120	
121	/*
122	 * This object is created when the actor is initialized: i.e. it is the passed
123	 * version of the isolate that was passed to the actor: primitive by the creating actor.
124	 */
125	private ATObject behaviour_;
126	
127	public ELActor(ATActorMirror mirror, ELVirtualMachine host) {
128		super("actor " + mirror.toString());
129		id_ = new ActorID();
130		mirror_ = mirror;
131		host_ = host;
132		receptionists_ = new ReceptionistsSet(this);
133	}
134	
135	/** constructor dedicated to initialization of discovery actor */
136	protected ELActor(ELVirtualMachine host) {
137		super("discovery actor");
138		id_ = new ActorID();
139		mirror_ = new NATActorMirror(host);
140		host_ = host;
141		receptionists_ = new ReceptionistsSet(this);
142	}
143
144	/**
145	 * Actor event loops handle events by allowing the meta-level events to
146	 * process themselves.
147	 */
148	public void handle(Event event) {
149		event.process(mirror_);
150	}
151	
152	public ATActorMirror getImplicitActorMirror() { return mirror_; }
153
154	public void setActorMirror(ATActorMirror mirror) { mirror_ = mirror; }
155	
156	public ELVirtualMachine getHost() {
157		return host_;
158	}
159
160	public ATObject getBehaviour() {
161		return behaviour_;
162	}
163	
164	public ActorID getActorID() {
165		return id_;
166	}
167	
168	public Thread getExecutor() {
169		return processor_;
170	}
171	
172	/**
173	 * Takes offline a given remote object such that it is no longer remotely accessible.
174	 * @param object a **far?** reference to the object to export
175	 * @throws XIllegalOperation if the passed object is not part of the export table - i.e. non-remotely accessible.
176	 */
177	public void takeOffline(ATObject object) throws InterpreterException {
178		// receptionist set will check whether ATObject is really remote to me
179		receptionists_.takeOfflineObject(object);
180	}
181	
182	/**
183	 * Resolve the given object id into a local reference. There are three cases to
184	 * consider:
185	 *  A) The given id designates an object local to this actor: the returned object
186	 *     will be a **near** reference to the object (i.e. the object itself)
187	 *  B) The given id designates a far (non-local) object that lives in the same
188	 *     address space as this actor: the returned object wil be a **far** reference
189	 *     to the object.
190	 *  C) The given id designates a far object that lives on a remote machine: the
191	 *     returned object will be a **far** and **remote** reference to the object.
192	 *     
193	 * @param id the identifier of the object to resolve
194	 * @return a near or far reference to the object, depending on where the designated object lives
195	 */
196	public ATObject resolve(ATObjectID id, ATTypeTag[] types) throws XObjectOffline {
197		return receptionists_.resolveObject(id, types);
198	}
199	
200	/* -----------------------------
201	 * -- Initialisation Protocol --
202	 * ----------------------------- */
203
204	/**
205	 * Initialises the root using the contents of the init file stored by
206	 * the hosting virtual machine.
207	 * @throws InterpreterException
208	 */
209	protected void initRootObject() throws InterpreterException {
210		ATAbstractGrammar initialisationCode = host_.getInitialisationCode();
211		
212		// evaluate the initialization code in the context of the global scope
213		NATObject globalScope = Evaluator.getGlobalLexicalScope();
214		NATContext initCtx = new NATContext(globalScope, globalScope);
215		
216		initialisationCode.meta_eval(initCtx);
217	}
218	
219	/**
220	 * Initialises various fields in the lexical root of the actor, which are defined in the 
221	 * context of every actor. Candidates are a "system" field which allows the program to 
222	 * perform IO operations or a "~" field denoting the current working directory.
223	 * 
224	 * @throws InterpreterException when initialisation of a field fails
225	 */
226	protected void initSharedFields() throws InterpreterException {
227		SharedActorField[] fields = host_.getFieldsToInitialize();
228		NATObject globalScope = Evaluator.getGlobalLexicalScope();
229		
230		for (int i = 0; i < fields.length; i++) {
231			SharedActorField field = fields[i];
232			ATObject value = field.initialize();
233			if (value != null) {
234				globalScope.meta_defineField(field.getName(), value);
235			}
236		}
237	}
238	
239	// Events to be processed by the actor event loop
240	
241	/**
242	 * The initial event sent by the actor mirror to its event loop to intialize itself.
243	 * @param future the synchronization point with the creating actor, needs to be fulfilled with a far ref to the behaviour.
244	 * @param parametersPkt the serialized parameters for the initialization code
245	 * @param initcodePkt the serialized initialization code (e.g. the code in 'actor: { code }')
246	 */
247	protected void event_init(final BlockingFuture future, final Packet parametersPkt, final Packet initcodePkt) {
248		receive(new Event("init("+this+")") {
249			public void process(Object byMyself) {
250				try {
251					behaviour_ = new NATObject();
252					
253					// pass far ref to behaviour to creator actor who is waiting for this
254					future.resolve(receptionists_.exportObject(behaviour_));
255					
256					// !! WARNING: the following code is also duplicated in
257					// ELDiscoveryActor's event_init. If this code is modified, don't
258					// forget to modify that of the discovery actor as well !!
259					
260					// initialize lexically visible fields
261					initSharedFields();
262
263					// go on to initialize the root and all lexically visible fields
264					initRootObject();
265
266					ATTable params = parametersPkt.unpack().asTable();
267					ATMethod initCode = initcodePkt.unpack().asMethod();					
268					
269					// initialize the behaviour using the parameters and the code
270					initCode.base_applyInScope(params, new NATContext(behaviour_, behaviour_));
271				} catch (InterpreterException e) {
272					Logging.Actor_LOG.error(behaviour_ + ": could not initialize actor behaviour", e);
273				}
274			}
275		});
276	}
277	
278	/**
279	 * The main entry point for any asynchronous self-sends.
280	 * Asynchronous self-sends (i.e. intra-actor sends) do not undergo any form of parameter passing,
281	 * there is no need to serialize and deserialize the message parameter in a Packet.
282	 * 
283	 * When an actor receives an asynchronous message for a given receiver, it delegates control
284	 * to the message itself by means of the message's <tt>process</tt> method.
285	 * @throws InterpreterException 
286	 */
287	public void acceptSelfSend(final ATObject receiver, final ATAsyncMessage msg) throws InterpreterException {
288		// This is the only place where messages are scheduled
289		// The receiver is always a local object, receive has
290		// already been invoked.
291    	mirror_.base_schedule(receiver, msg);
292    	// signal a serve event for every message that is accepted
293    	this.event_serve();
294	}
295	
296	/**
297	 * The main entry point for any asynchronous messages sent to this actor
298	 * by external sources.
299	 * @param sender address of the sending actor, used to notify when the receiver has gone offline.
300	 * @param serializedMessage the asynchronous AmbientTalk base-level message to enqueue
301	 */
302	public void event_remoteAccept(final Address sender, final Packet serializedMessage) {
303		receive(new Event("remoteAccept("+serializedMessage+")") {
304			public void process(Object myActorMirror) {
305			  try {
306				// receive a pair [receiver, message]
307				ATObject[] pair = serializedMessage.unpack().asNativeTable().elements_;
308				ATObject receiver = pair[0];
309				ATAsyncMessage msg = pair[1].asAsyncMessage();
310				performAccept(receiver, msg);
311			  } catch (XObjectOffline e) {
312				 host_.event_objectTakenOffline(e.getObjectId(), sender);
313				Logging.Actor_LOG.error(mirror_ + ": error unpacking "+ serializedMessage, e);
314			  }  catch (InterpreterException e) {
315				Logging.Actor_LOG.error(mirror_ + ": error unpacking "+ serializedMessage, e);
316			  } 
317		    }
318		});
319	}
320	
321	/**
322	 * The main entry point for any asynchronous messages sent to this actor 
323	 * by local actors.
324	 * @param ref the local reference of the sending actor, used to notify when the receiver has gone offline.
325	 * @param serializedMessage the asynchronous AmbientTalk base-level message to enqueue
326	 */
327	public void event_localAccept(final NATLocalFarRef ref, final Packet serializedMessage) {
328		receive(new Event("localAccept("+serializedMessage+")") {
329			public void process(Object myActorMirror) {
330			  try {
331				// receive a pair [receiver, message]
332				ATObject[] pair = serializedMessage.unpack().asNativeTable().elements_;
333				ATObject receiver = pair[0];
334				ATAsyncMessage msg = pair[1].asAsyncMessage();
335				performAccept(receiver, msg);
336			  } catch (XObjectOffline e) {
337				  ref.notifyTakenOffline();
338				  Logging.Actor_LOG.error(mirror_ + ": error unpacking "+ serializedMessage, e);
339			  } catch (InterpreterException e) {
340				  Logging.Actor_LOG.error(mirror_ + ": error unpacking "+ serializedMessage, e);
341			  } 
342		    }
343		});
344	}
345	
346	public void event_serve() {
347		receive(new Event("serve()") {
348			public void process(Object myActorMirror) {
349				try {
350					ATObject result = mirror_.base_serve();
351					Logging.Actor_LOG.debug(mirror_ + ": serve() returned " + result);
352				} catch (InterpreterException e) {
353					System.out.println(">>> Exception in actor " + myActorMirror + ": "+e.getMessage());
354					e.printAmbientTalkStackTrace(System.out);
355					Logging.Actor_LOG.error(mirror_ + ": serve() failed ", e);
356				}
357			}
358		});
359	}
360	
361	private void performAccept(ATObject receiver, ATAsyncMessage msg) {
362		try {
363			ATObject result = mirror_.base_receive(receiver, msg);
364			Logging.Actor_LOG.debug(mirror_ + ": scheduling "+ msg + " returned " + result);
365			
366			// signal a serve event for every message that is accepted
367			event_serve();
368		} catch (InterpreterException e) {
369			System.out.println(">>> Exception in actor " + getImplicitActorMirror() + ": "+e.getMessage());
370			e.printAmbientTalkStackTrace(System.out);
371			Logging.Actor_LOG.error(mirror_ + ": scheduling "+ msg + " failed ", e);
372		}
373	}
374	
375	/**
376	 * This method is invoked by a coercer in order to schedule a purely asynchronous symbiotic invocation
377	 * from the Java world.
378	 * 
379	 * This method schedules the call for asynchronous execution. Its return value and or raised exceptions
380	 * are ignored. This method should only be used for {@link Method} objects whose return type is <tt>void</tt>
381	 * and whose declaring class is a subtype of {@link EventListener}. It represents asynchronous method
382	 * invocations from the Java world to the AmbientTalk world.
383	 * 
384	 * @param principal the AmbientTalk object owned by this actor on which to invoke the method
385	 * @param method the Java method that was symbiotically invoked on the principal
386	 * @param args the arguments to the Java method call, already converted into AmbientTalk values
387	 */
388	public void event_symbioticInvocation(final ATObject principal, final Method method, final ATObject[] args) {
389		receive(new Event("asyncSymbioticInv of "+method.getName()) {
390			public void process(Object actorMirror) {
391				try {
392					Reflection.downInvocation(principal, method, args);
393				} catch (InterpreterException e) {
394					System.out.println(">>> Exception in actor " + actorMirror + ": "+e.getMessage());
395					e.printAmbientTalkStackTrace(System.out);
396					Logging.Actor_LOG.error("asynchronous symbiotic invocation of "+method.getName()+" failed", e);
397				}
398			}
399		});
400	}
401	
402	/**
403	 * This method is invoked by a coercer in order to schedule a symbiotic invocation
404	 * from the Java world, which should be synchronous to the Java thread, but which
405	 * must be scheduled asynchronously to comply with the AT/2 actor model.
406	 * 
407	 * The future returned by this method makes the calling (Java) thread <b>block</b> upon
408	 * accessing its value, waiting until the actor has processed the symbiotic invocation.
409	 * 
410	 * @param principal the AmbientTalk object owned by this actor on which to invoke the method
411	 * @param meth the Java method that was symbiotically invoked on the principal
412	 * @param args the arguments to the Java method call, already converted into AmbientTalk values
413	 * @return a Java future that is resolved with the result of the symbiotic invocation
414	 * @throws Exception if the symbiotic invocation fails
415	 */
416	public BlockingFuture sync_event_symbioticInvocation(final ATObject principal, final Method meth, final ATObject[] args) throws Exception {
417		return receiveAndReturnFuture("syncSymbioticInv of " + meth.getName(), new Callable() {
418			public Object call(Object actorMirror) throws Exception {
419				Class targetType = meth.getReturnType();
420				ATObject[] actualArgs = args;
421				// if the return type is BlockingFuture, the first argument should specify the type
422				// of the value with which BlockingFuture will be resolved
423				if (targetType.equals(BlockingFuture.class)) {
424					if ((meth.getParameterTypes().length > 0) && (meth.getParameterTypes()[0].equals(Class.class))) {
425						targetType = args[0].asJavaClassUnderSymbiosis().getWrappedClass();
426						// drop first argument, it only exists to specify the targetType
427						ATObject[] newArgs = new ATObject[args.length-1];
428						System.arraycopy(args, 1, newArgs, 0, newArgs.length);
429						actualArgs = newArgs;
430					}
431				}
432				
433				ATObject result = Reflection.downInvocation(principal, meth, actualArgs);
434				// SUPPORT FOR FUTURES
435				if (Symbiosis.isAmbientTalkFuture(result)) {
436					Logging.Actor_LOG.debug("Symbiotic futures: symbiotic call to " + meth.getName() + " returned an AT future");
437					return Symbiosis.ambientTalkFutureToJavaFuture(result, targetType);
438				} else {
439					// return the proper value immediately
440					return Symbiosis.ambientTalkToJava(result, targetType);
441				}
442			}
443		});
444	}
445	
446	/**
447	 * This method should only be used for purposes such as the IAT shell or unit testing.
448	 * It allows an external thread to make this actor evaluate an arbitrary expression.
449	 * 
450	 * @param ast an abstract syntax tree to be evaluated by the receiving actor (in the
451	 * scope of its behaviour).
452	 * @return the result of the evaluation
453	 * @throws InterpreterException if the evaluation fails
454	 */
455	public ATObject sync_event_eval(final ATAbstractGrammar ast) throws InterpreterException {
456		try {
457			return (ATObject) receiveAndWait("nativeEval("+ast+")", new Callable() {
458				public Object call(Object inActor) throws Exception {
459				    return OBJLexicalRoot._INSTANCE_.base_eval_in_(ast, behaviour_);
460				}
461			});
462		} catch (Exception e) {
463			throw (InterpreterException) e;
464		}
465	}
466	
467	/**
468	 * This method should only be used for purposes of unit testing. It allows
469	 * arbitary code to be scheduled by external threads such as unit testing frameworks.
470	 */
471	public Object sync_event_performTest(Callable c) throws Exception {
472		return (ATObject) receiveAndWait("performTest("+c+")", c);
473	}
474	
475	/**
476	 * When the discovery manager receives a publication from another local actor or
477	 * another remote VM, the actor is asked to compare the incoming publication against
478	 * a subscription that it had announced previously.
479	 * 
480	 * @param requiredTypePkt serialized form of the type attached to the actor's subscription
481	 * @param myHandler the closure specified as a handler for the actor's subscription
482	 * @param discoveredTypePkt serialized form of the type attached to the new publication
483	 * @param remoteServicePkt serialized form of the reference to the remote discovered service
484	 */
485	public void event_serviceJoined(final Packet requiredTypePkt, final ATFarReference myHandler,
486			                        final Packet discoveredTypePkt, final Packet remoteServicePkt) {
487		receive(new Event("serviceJoined") {
488			public void process(Object myActorMirror) {
489				try {
490					ATTypeTag requiredType = requiredTypePkt.unpack().asTypeTag();
491					ATTypeTag discoveredType = discoveredTypePkt.unpack().asTypeTag();
492					// is there a match?
493					if (discoveredType.base_isSubtypeOf(requiredType).asNativeBoolean().javaValue) {
494						ATObject remoteService = remoteServicePkt.unpack();
495						// myhandler<-apply([remoteService])@[]
496						Evaluator.trigger(myHandler, NATTable.of(remoteService));
497					}
498				} catch (XIOProblem e) {
499					Logging.Actor_LOG.error("Error deserializing joined types or services: ", e.getCause());
500				} catch (XClassNotFound e) {
501					Logging.Actor_LOG.fatal("Could not find class while deserializing joined types or services: ", e.getCause());
502				} catch (InterpreterException e) {
503					Logging.Actor_LOG.error("Error while joining services: ", e);
504				}
505			}
506		});
507	}
508}