private void logBytes(Pair<Object, byte[]> pair) { ObjectMapper objectMapper = new ObjectMapper(); String buffer = new String(pair.getRight(), 4, pair.getRight().length - 4, StandardCharsets.UTF_8); logger.write(buffer); try { logger.write(objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(objectMapper.readValue(buffer, Object.class))); } catch (IOException e) { e.printStackTrace(); } logger.write(InternalUtils.hexDump(32, pair.getRight(), 0, pair.getRight().length)); }
public static <T> Class<T> classForName(final String className) { return classForName(className, false); }
public <R> Task<R> execute(Supplier<Task<R>> taskSupplier) { final Task<R> completion = new Task<>(); if ((maxQueueSize > 0 && queueSize >= maxQueueSize) || !queue.add(() -> { Task<R> source = InternalUtils.safeInvoke(taskSupplier); InternalUtils.linkFutures(source, completion); return source; })) { throw new IllegalStateException(String.format("Queue full (%d > %d)", queue.size(), maxQueueSize)); } queueSizeUpdater.incrementAndGet(this); tryDrainQueue(); return completion; }
if (entry != null) final Task<Object> result = InternalUtils.safeInvoke(() -> entry.run( target -> performInvocation(ctx, invocation, entry, target))); InternalUtils.linkFuturesOnError(result, invocation.getCompletion()); InternalUtils.safeInvoke(() -> executionSerializer.offerJob(toReference, () -> onActivate(ctx, invocation), maxQueueSize));
protected Task<Object> performLocalInvocation(final Invocation invocation, final ObjectInvoker invoker, final LocalObjects.LocalObjectEntry target) { Task result = invoker.safeInvoke(target.getObject(), invocation.getMethodId(), invocation.getParams()); try { // must await to hold the execution serializer await(result); } catch (Throwable ex) { // handled bellow; } if (invocation.getCompletion() != null) { InternalUtils.linkFutures(result, invocation.getCompletion()); } return result; }
/** * Only accepts if the queue size is not exceeded. * * @return true if the task was accepted. */ @Override public <R> Task<R> offerJob(T key, Supplier<Task<R>> job, int maxQueueSize) { // todo remove this. if (key == null) { executorService.execute(() -> InternalUtils.safeInvoke(job)); } return getSerializer(key).executeSerialized(() -> InternalUtils.safeInvoke(job), maxQueueSize); }
@SuppressWarnings("unchecked") public <T> Task<StreamSubscriptionHandle<T>> subscribe(String provider, Class<T> dataClass, String streamId, AsyncObserver<T> observer) { StreamKey streamKey = new StreamKey(provider, dataClass, streamId); ConcurrentMap<Handle, AsyncObserver> observers = observerMap.get(streamKey); if (observers == null) { observers = InternalUtils.putIfAbsentAndGet(observerMap, streamKey, new ConcurrentHashMap<>()); ServerSideStreamProxy serverSideStreamProxy = runtime.getRemoteObserverReference(null, ServerSideStreamProxy.class, "0"); int dataClassId = DefaultClassDictionary.get().getClassId(dataClass); Task<StreamSubscriptionHandle<Object>> subscriptionHandleTask = serverSideStreamProxy.subscribe(provider, dataClassId, streamId, localReference); await(subscriptionHandleTask); } observers = (observers != null) ? observers : InternalUtils.putIfAbsentAndGet(observerMap, streamKey, new ConcurrentHashMap<>()); Handle handle = new Handle(streamKey, nextId.incrementAndGet()); observers.put(handle, observer); return Task.fromValue(handle); }
InternalUtils.sleep(250); } while (executionSerializer.isBusy());
private Task<Void> onActivate(HandlerContext ctx, final Invocation invocation) { // this must run serialized by the remote reference key. LocalObjects.LocalObjectEntry<Object> entry = objects.findLocalObjectByReference(invocation.getToReference()); if (entry == null) { objects.registerLocalObject(invocation.getToReference()); entry = objects.findLocalObjectByReference(invocation.getToReference()); } // queues the invocation final LocalObjects.LocalObjectEntry<Object> theEntry = entry; final Task result = entry.run(target -> performInvocation(ctx, invocation, theEntry, target)); if (invocation.getCompletion() != null) { InternalUtils.linkFuturesOnError(result, invocation.getCompletion()); } // yielding since we blocked the entry before running on activate (serialized execution) return Task.done(); }
InternalUtils.linkFutures(invokeResult, invocation.getCompletion());
private <R> Task<R> doRunInternal( ActorEntry<T> entry1, LocalObjects.LocalObjectEntry<T> entry2, final TaskFunction<LocalObjects.LocalObjectEntry<T>, R> function) { try { Task<R> res = InternalUtils.safeInvoke(() -> function.apply(entry2)); // the await here is to ensure that the finally block executed at the right time. await(res); return res; } finally { if (isDeactivated() || entry1 != entry2) { await(entry1.deactivate()); } else { push(entry1); } } }
@Override public void onRead(HandlerContext ctx, final Object msg) { Pair<NodeAddress, byte[]> message = (Pair<NodeAddress, byte[]>) msg; Message msg1 = null; try { msg1 = messageSerializer.deserializeMessage(runtime, message.getRight()); if (msg1.getFromNode() == null) { msg1.setFromNode(message.getLeft()); } } catch (Throwable e) { logger.error("Error deserializing message", e); logger.error(InternalUtils.hexDump(32, message.getRight(), 0, message.getRight().length)); } if (msg1 != null) { ctx.fireRead(msg1); } }
@Override public <R> Task<R> executeSerialized(Supplier<Task<R>> taskSupplier, int maxQueueSize) { final Task<R> completion = new Task<>(); int queueSize = size; if (DEBUG_ENABLED && queueSize >= maxQueueSize / 10) { logger.debug("Queued " + queueSize + " / " + maxQueueSize + " for " + key); } if (queueSize >= maxQueueSize || !queue.add(() -> { Task<R> source = InternalUtils.safeInvoke(taskSupplier); InternalUtils.linkFutures(source, completion); return source; })) { return Task.fromException(new IllegalStateException(String.format("Queue full for %s (%d > %d)", key, queue.size(), maxQueueSize))); } // managing the size like this to avoid using ConcurrentLinkedQueue.size() sizeUpdater.incrementAndGet(this); tryExecute(false); return completion; }
if (invocation.getCompletion() != null) InternalUtils.linkFutures(write, invocation.getCompletion());
public boolean canActivateActor(final String interfaceName) { if (getState() != NodeCapabilities.NodeState.RUNNING) { // todo, improve this if (hosting.getServerNodes().size() > 1) { return false; } } Class<Actor> aInterface = InternalUtils.classForName(interfaceName, true); if (aInterface == null) { return false; } final Class<?> concreteClass = finder.findActorImplementation(aInterface); return concreteClass != null; }
logger.trace("Payload for message #" + messageId + InternalUtils.hexDump(32, raw, 0, raw.length));