public ObjectInvoker<?> getInvoker(final int interfaceId) { final ClassDescriptor descriptor = getDescriptor(interfaceId); if (descriptor == null) { return getInvoker(DefaultClassDictionary.get().getClassById(interfaceId)); } if (descriptor.invoker == null) { descriptor.invoker = dynamicReferenceFactory.getInvokerFor(descriptor.factory.getInterface()); } return descriptor.invoker; }
@Override public <T> T getReference(BasicRuntime runtime, NodeAddress address, Class<T> iClass, Object id) { return DefaultDescriptorFactory.get().getReference(this, address, iClass, id); }
@Override protected ByteArrayOutput create(int bufferSize) { return new ByteArrayOutput(bufferSize, MAX_BUFFER_SIZE, new BufferAwareByteArrayOutputStream(bufferSize)); }
private String getInvokedClassAndMethodName(Message message) { if (message.getInterfaceId() != 0) { final Class clazz = DefaultClassDictionary.get().getClassById(message.getInterfaceId()); if (clazz != null) { final Method method = DefaultDescriptorFactory.get().getInvoker(clazz).getMethod(message.getMethodId()); return clazz.getSimpleName() + "." + method.getName(); } } return null; }
@Override public Object copy(final Kryo kryo, final Object original) { if (original instanceof RemoteReference) { final RemoteReference<?> remoteReference = (RemoteReference<?>) original; if (RemoteReference.getRuntime(remoteReference) != null) { return DefaultDescriptorFactory.get().getReference(null, RemoteReference.getAddress(remoteReference), RemoteReference.getInterfaceClass(remoteReference), RemoteReference.getId(remoteReference)); } } return original; }
@Override public void onRead(final HandlerContext ctx, final Object msg) throws Exception { Message message = (Message) msg; final Class<?> clazz = DefaultClassDictionary.get().getClassById(message.getInterfaceId()); // TODO: check method access, check object access } }
default ObjectInvoker<?> getInvoker(int classId) { return getInvoker(DefaultClassDictionary.get().getClassById(classId)); }
@SuppressWarnings("unchecked") protected Task<Object> doInvoke(final Stage runtime, final Invocation invocation, final LocalObjects.LocalObjectEntry entry, final LocalObjects.LocalObjectEntry target, final Method method, final Boolean reentrant, final ObjectInvoker invoker) { final long startTimeNanos = System.nanoTime(); beforeInvoke(invocation, method); final Task<Object> invokeResult = invoker.safeInvoke(target.getObject(), invocation.getMethodId(), invocation.getParams()); afterInvoke(startTimeNanos, invocation, method); invokeResult.whenComplete((o, throwable) -> taskComplete(startTimeNanos, invocation, method)); return invokeResult; }
default ObjectInvoker<?> getInvoker(Class clazz) { return DefaultDescriptorFactory.get().getInvoker(clazz); }
@Override public void write(Kryo kryo, Output output, Object object) { ActorObserver objectReference = BasicRuntime.getRuntime().registerObserver(null, (ActorObserver) object); RemoteReference reference = (RemoteReference) objectReference; ReferenceReplacement replacement = new ReferenceReplacement(); replacement.address = reference.address; replacement.interfaceClass = reference._interfaceClass(); replacement.id = reference.id; kryo.writeObject(output, replacement); }
/** * @return the result of the method called */ @SuppressWarnings("unchecked") public Task scheduleLocalInvocation(final LocalObjects.LocalObjectEntry<Object> localObjectEntry, final Invocation invocation) { ObjectInvoker invoker = runtime.getInvoker(RemoteReference.getInterfaceId(invocation.getToReference())); return localObjectEntry.run(target -> performLocalInvocation(invocation, invoker, target) ); }
private <R> Task<R> doRun(final TaskFunction<LocalObjects.LocalObjectEntry<T>, R> function) { runtime.bind(); final ActorTaskContext actorTaskContext = ActorTaskContext.pushNew(); try { // using await makes the actorTaskContext.pop() run in the wrong thread. // the the internal par is separated return doRunInternal(function, actorTaskContext); } finally { actorTaskContext.pop(); } }
private <R> Task<R> doRunInternal(final TaskFunction<LocalObjects.LocalObjectEntry<T>, R> function, final ActorTaskContext actorTaskContext) { if (actor == null && !isDeactivated()) { this.actor = await(activate()); runtime.bind(); } actorTaskContext.setActor(this.getObject()); return function.apply(this); }
@Override protected boolean recycle(ByteArrayOutput output) { if (output.getByteArrayOutputStream().getBufferSize() < MAX_POOLED_BUFFER_SIZE) { output.getByteArrayOutputStream().reset(); output.clear(); return true; } return false; // discard } }
@Override public <T extends ActorObserver> T registerObserver(Class<T> iClass, String id, final T observer) { final RemoteReference<T> reference = objects.getOrAddLocalObjectReference(hosting.getNodeAddress(), iClass, id, observer); RemoteReference.setRuntime(reference, this); //noinspection unchecked return iClass != null ? iClass.cast(reference) : (T) reference; }
@Override public NodeAddress getLocalAddress() { return hosting.getNodeAddress(); }
/** * Removes a previously registered reminder. * * @param reminderName the remainder's name * @return completion promise for this operation */ protected Task<?> unregisterReminder(String reminderName) { return runtime.unregisterReminder((Remindable) reference, reminderName); }
@SuppressWarnings("unchecked") protected <T> RemoteReference<T> createReference(NodeAddress address, Class<T> iClass, String objectId) { final T reference = DefaultDescriptorFactory.get().getReference(iClass, objectId); if (address != null) { ((RemoteReference) reference).address = address; } return (RemoteReference<T>) reference; }
@Override public <T> T getReference(final BasicRuntime runtime, final NodeAddress address, final Class<T> iClass, final Object id) { return DefaultDescriptorFactory.get().getReference(this, address, iClass, id); }