private WonMessage processSelected(List<MessageAndPlaceholder> selected, WonMessage message) { Dataset messageDataset = message.getCompleteDataset(); URI outerEnvelopeGraphURI = message.getOuterEnvelopeGraphURI(); URI messageUri = message.getMessageURI(); selected.forEach((MessageAndPlaceholder m) -> { addSignatureReferenceToMessage(messageDataset, messageUri, outerEnvelopeGraphURI, m.getWonMessage()); }); WonMessage newMessage = new WonMessage(messageDataset); selected.forEach((MessageAndPlaceholder m) -> { newMessage.addMessageProperty(WONMSG.HAS_PREVIOUS_MESSAGE_PROPERTY, m.getMessageEventPlaceholder().getMessageURI()); }); return newMessage; }
public MessageEventPlaceholder(URI parentURI, WonMessage wonMessage, EventContainer eventContainer) { this.parentURI = parentURI; this.messageURI = wonMessage.getMessageURI(); this.messageType = wonMessage.getMessageType(); this.senderURI = wonMessage.getSenderURI(); this.senderNeedURI = wonMessage.getSenderNeedURI(); this.senderNodeURI = wonMessage.getSenderNodeURI(); this.receiverURI = wonMessage.getReceiverURI(); this.receiverNeedURI = wonMessage.getReceiverNeedURI(); this.receiverNodeURI = wonMessage.getReceiverNodeURI(); this.creationDate = new Date(); this.correspondingRemoteMessageURI = wonMessage.getCorrespondingRemoteMessageURI(); this.referencedByOtherMessage = false; this.innermostMessageURI = wonMessage.getInnermostMessageURI(); this.eventContainer = eventContainer; }
private boolean hasSameEnvelopeData(final WonMessage processedMessage, final WonMessage message) { if ( equalsOrBothNull(processedMessage.getSenderNeedURI(), message.getSenderNeedURI()) && equalsOrBothNull(processedMessage.getReceiverNeedURI(), message.getReceiverNeedURI()) equalsOrBothNull(processedMessage.getReceiverURI(), message.getReceiverURI()) && equalsOrBothNull(processedMessage.getSenderNodeURI(), message.getSenderNodeURI()) && equalsOrBothNull(processedMessage.getReceiverNodeURI(), message.getReceiverNodeURI()) equalsOrBothNull(processedMessage.getIsResponseToMessageURI(), message.getIsResponseToMessageURI()) && processedMessage.getContentGraphURIs().containsAll(message.getContentGraphURIs()) && equalsOrBothNull(processedMessage.getMessageType(), message.getMessageType()) && processedMessage.getRefersTo().containsAll(message.getRefersTo()) && equalsOrBothNull(processedMessage.getEnvelopeType(), message.getEnvelopeType()) ) { return true;
private static URI getParentUriFromSenderProperties(WonMessage message) { URI parentURI; parentURI = message.getSenderURI(); if (parentURI == null) { parentURI = message.getSenderNeedURI(); } if (parentURI == null) { parentURI = message.getSenderNodeURI(); } return parentURI; }
public synchronized URI getMessageURI() { if (this.messageURI == null) { this.messageURI = findMessageUri(getOuterEnvelopeGraph(), getOuterEnvelopeGraphURI().toString()); } return this.messageURI; }
/** * Copies the envelope properties from the specified message to this message. * * Note that this does not copy the original envelope graph, only the * standard envelope properties. * * @param wonMessage * @return */ public static WonMessageBuilder copyEnvelopeFromWonMessage(final WonMessage wonMessage) { WonMessageBuilder builder = new WonMessageBuilder(wonMessage.getMessageURI()) .setWonMessageType(wonMessage.getMessageType()) .setReceiverURI(wonMessage.getReceiverURI()) .setReceiverNeedURI(wonMessage.getReceiverNeedURI()) .setReceiverNodeURI(wonMessage.getReceiverNodeURI()) .setSenderURI(wonMessage.getSenderURI()) .setSenderNeedURI(wonMessage.getSenderNeedURI()) .setSenderNodeURI(wonMessage.getSenderNodeURI()); if (wonMessage.getIsResponseToMessageType() != null){ builder.setIsResponseToMessageType(wonMessage.getIsResponseToMessageType()); } if (wonMessage.getIsResponseToMessageURI() != null){ builder.setIsResponseToMessageURI(wonMessage.getIsResponseToMessageURI()); } if (wonMessage.getIsRemoteResponseToMessageURI() != null){ builder.setIsRemoteResponseToMessageURI(wonMessage.getIsRemoteResponseToMessageURI()); } return builder; }
WonMessage wonMessage = (WonMessage) message.getHeader(WonCamelConstants.MESSAGE_HEADER); URI connectionURIFromWonMessage = wonMessage.getReceiverURI(); Connection con = null; if (connectionURIFromWonMessage == null) { wonMessage.getReceiverNeedURI(), wonMessage.getSenderNeedURI(), facet); if (con == null) { URI connectionUri = wonNodeInformationService.generateConnectionURI(wonMessage.getReceiverNodeURI()); con = dataService.createConnection(connectionUri, wonMessage.getReceiverNeedURI(), wonMessage.getSenderNeedURI(), wonMessage.getSenderURI(), facet, ConnectionState.REQUEST_RECEIVED, ConnectionEventType.PARTNER_OPEN); if (!con.getRemoteNeedURI().equals(wonMessage.getSenderNeedURI())) throw new IllegalStateException("the remote need uri of the connection must be equal to the sender need uri of the message"); if (wonMessage.getSenderURI() == null) throw new IllegalStateException("the sender uri must not be null"); con.setRemoteConnectionURI(wonMessage.getSenderURI()); if (!con.getRemoteConnectionURI().equals(wonMessage.getSenderURI())) throw new IllegalStateException("the sender uri of the message must be equal to the remote connection uri"); con.setState(con.getState().transit(ConnectionEventType.PARTNER_OPEN)); connectionRepository.save(con); wonMessage.addMessageProperty(WONMSG.RECEIVER_PROPERTY, con.getConnectionURI());
@Override protected void doRun(Event event, EventListener executingListener) throws Exception { WonMessage responseWonMessage = null; if (event instanceof SuccessResponseEvent) { responseWonMessage = ((SuccessResponseEvent)event).getMessage(); } else if (event instanceof FailureResponseEvent) { responseWonMessage = ((FailureResponseEvent)event).getMessage(); } else { //can't process any other events return; } logger.debug("eagerly caching data in reaction to event {}", event); //put received message into cache LinkedDataSource linkedDataSource = context.getLinkedDataSource(); if (linkedDataSource instanceof CachingLinkedDataSource) { URI requester = responseWonMessage.getReceiverNeedURI(); ((CachingLinkedDataSource) linkedDataSource).addToCache(responseWonMessage.getCompleteDataset(), responseWonMessage.getMessageURI(), requester); //load the original message(s) into cache, too Set<URI> toLoad = new HashSet<URI>(); addIfNotNull(toLoad, responseWonMessage.getIsRemoteResponseToMessageURI()); addIfNotNull(toLoad, responseWonMessage.getIsResponseToMessageURI()); addIfNotNull(toLoad, responseWonMessage.getCorrespondingRemoteMessageURI()); List<URI> previous = WonRdfUtils.MessageUtils.getPreviousMessageUrisIncludingRemote(responseWonMessage); addIfNotNull(toLoad, previous); toLoad.forEach(uri -> linkedDataSource.getDataForResource(uri, requester)); } }
@Override public WonMessage process(final WonMessage message) throws WonMessageProcessingException { try { if (message.getMessageType() == WonMessageType.CREATE_NEED) { String needUri = message.getSenderNeedURI().toString(); Dataset msgDataset = WonMessageEncoder.encodeAsDataset(message); // generate and add need's public key to the need content String alias = keyPairAliasDerivationStrategy.getAliasForNeedUri(needUri); if (cryptographyService.getPrivateKey(alias) == null) { cryptographyService.createNewKeyPair(alias, alias); } PublicKey pubKey = cryptographyService.getPublicKey(alias); WonKeysReaderWriter keyWriter = new WonKeysReaderWriter(); String contentName = message.getContentGraphURIs().get(0); Model contentModel = msgDataset.getNamedModel(contentName); keyWriter.writeToModel(contentModel, contentModel.createResource(needUri), pubKey); return new WonMessage(msgDataset); } } catch (Exception e) { logger.error("Failed to add key", e); throw new WonMessageProcessingException("Failed to add key for need in message " + message.getMessageURI().toString()); } return message; }
@Override public boolean matches(Exchange exchange) { WonMessage message = (WonMessage) exchange.getIn().getHeader(WonCamelConstants.ORIGINAL_MESSAGE_HEADER); if (message == null) return false; if (message.getEnvelopeType() != WonMessageDirection.FROM_SYSTEM) return false; if (message.getSenderURI() != null) { return message.getSenderURI().equals(message.getReceiverURI()); } else { if (message.getSenderNeedURI() == null) return false; return message.getSenderNeedURI().equals(message.getReceiverNeedURI()); } } }
WonMessage wonMessage = (WonMessage) message.getHeader(WonCamelConstants.MESSAGE_HEADER); logger.debug("STORING message with id {}", wonMessage.getMessageURI()); URI needURIFromWonMessage = wonMessage.getReceiverNeedURI(); if (isTooManyHints(needURIFromWonMessage)) { exchange.getIn().setHeader(WonCamelConstants.IGNORE_HINT, Boolean.TRUE); URI wonNodeFromWonMessage = wonMessage.getReceiverNodeURI(); URI otherNeedURIFromWonMessage = URI.create(RdfUtils.findOnePropertyFromResource( wonMessage.getMessageContent(), wonMessage.getMessageURI(), WON.HAS_MATCH_COUNTERPART).asResource().getURI()); wonMessage.getMessageContent(), wonMessage.getMessageURI(), WON.HAS_MATCH_SCORE).asLiteral().getDouble(); URI wmOriginator = wonMessage.getSenderNodeURI(); if (wmScore < 0 || wmScore > 1) throw new IllegalArgumentException("score is not in [0,1]"); if (wmOriginator == null) wonMessage.addMessageProperty(WONMSG.RECEIVER_PROPERTY, con.getConnectionURI());
private void logRouteStart(Exchange exchange) { //UnitOfWork -> getRouteContext -> Route -> Id. String routeId = exchange.getUnitOfWork().getRouteContext().getRoute().getId(); WonMessage message = (WonMessage) exchange.getIn().getHeader(WonCamelConstants.MESSAGE_HEADER); if (message == null){ logger.debug("starting route {}: [no WoNMessage]", routeId); return; } logger.debug("starting route {}: {} type:{}, dir:{}, resp:{}, rem: {}", new String[]{ routeId, message.getMessageURI().toString(), message.getMessageType().toString(), message.getEnvelopeType().toString(), message.getIsResponseToMessageURI() == null ? "[not a response]" : message.getIsResponseToMessageURI().toString(), message.getCorrespondingRemoteMessageURI() == null ? "[no remote message uri]" : message.getCorrespondingRemoteMessageURI().toString() }); }
public void process(final Exchange exchange) throws Exception { Message message = exchange.getIn(); WonMessage wonMessage = (WonMessage) message.getHeader(WonCamelConstants.MESSAGE_HEADER); URI senderNeedURI = wonMessage.getSenderNeedURI(); URI senderNodeURI = wonMessage.getSenderNodeURI(); URI receiverNeedURI = wonMessage.getReceiverNeedURI(); URI facetURI = WonRdfUtils.FacetUtils.getFacet(wonMessage); URI connectionURI = wonMessage.getSenderURI(); //if the uri is known already, we can load the connection! Connection con = null; if (connectionURI != null) { .generateEventURI(wonMessage.getReceiverNodeURI()); wonMessage.addMessageProperty(WONMSG.SENDER_PROPERTY, con.getConnectionURI()); wonMessage.addMessageProperty(WONMSG.HAS_CORRESPONDING_REMOTE_MESSAGE, remoteMessageUri);
@Override protected void doRun(Event event, EventListener executingListener) throws Exception { if (!(event instanceof MessageFromOtherNeedEvent)) { return; } logger.debug("eagerly caching data in reaction to event {}", event); MessageFromOtherNeedEvent msgEvent = (MessageFromOtherNeedEvent) event; WonMessage wonMessage = msgEvent.getWonMessage(); LinkedDataSource linkedDataSource = context.getLinkedDataSource(); if (linkedDataSource instanceof CachingLinkedDataSource) { ((CachingLinkedDataSource) linkedDataSource).addToCache(wonMessage.getCompleteDataset(), wonMessage.getMessageURI(), wonMessage.getReceiverNeedURI()); URI requester = wonMessage.getReceiverNeedURI(); Set<URI> toLoad = new HashSet<URI>(); addIfNotNull(toLoad, wonMessage.getCorrespondingRemoteMessageURI()); List<URI> previous = WonRdfUtils.MessageUtils.getPreviousMessageUrisIncludingRemote(wonMessage); addIfNotNull(toLoad, previous); toLoad.forEach(uri -> linkedDataSource.getDataForResource(uri, requester)); } }
public static WonMessage forwardReceivedNodeToNodeMessageAsNodeToNodeMessage(final URI newMessageUri, final WonMessage wonMessage, final URI connectionURI, final URI needURI, final URI wonNodeUri, final URI remoteConnectionURI, final URI remoteNeedURI, final URI remoteWonNodeUri) { WonMessageBuilder builder = new WonMessageBuilder(newMessageUri) .setWonMessageType(wonMessage.getMessageType()) .forward(wonMessage) .setForwardedMessageURI(wonMessage.getMessageURI()) .setSenderNeedURI(needURI) .setSenderURI(connectionURI) .setSenderNodeURI(wonNodeUri) .setSentTimestamp(System.currentTimeMillis()) .setReceiverURI(remoteConnectionURI) .setReceiverNeedURI(remoteNeedURI) .setReceiverNodeURI(remoteWonNodeUri) .setIsRemoteResponseToMessageURI(wonMessage.getIsRemoteResponseToMessageURI()) .setIsResponseToMessageURI(wonMessage.getIsResponseToMessageURI()) .setIsResponseToMessageType(wonMessage.getIsResponseToMessageType()) .setWonMessageDirection(WonMessageDirection.FROM_SYSTEM); return builder.build(); }
@Override public void process(Exchange exchange) throws Exception { Message message = exchange.getIn(); WonMessage wonMessage = (WonMessage) message.getHeader(WonCamelConstants.MESSAGE_HEADER); URI receiverNeedURI = wonMessage.getReceiverNeedURI(); URI senderNeedURI = wonMessage.getSenderNeedURI(); if (receiverNeedURI== null){ throw new MissingMessagePropertyException(URI.create(WONMSG.RECEIVER_NEED_PROPERTY.toString())); } if (senderNeedURI == null){ throw new MissingMessagePropertyException(URI.create(WONMSG.SENDER_NEED_PROPERTY.toString())); } if (!receiverNeedURI.equals(senderNeedURI)) { throw new IllegalArgumentException("sender need uri " + senderNeedURI +" does not equal receiver need uri " + receiverNeedURI); } Need need = needRepository.findOneByNeedURI(senderNeedURI); if (need == null){ throw new IllegalArgumentException("need not found - cannot send need message to: " + senderNeedURI); } need.getEventContainer().getEvents().add(messageEventRepository.findOneByMessageURIforUpdate(wonMessage.getMessageURI())); need = needRepository.save(need); } }
/** * Converts the specified hint message into a Match object. * @param wonMessage * @return a match object or null if the message is not a hint message. */ public static Match toMatch(final WonMessage wonMessage) { if (!WONMSG.TYPE_HINT.equals(wonMessage.getMessageType().getResource())){ return null; } Match match = new Match(); match.setFromNeed(wonMessage.getReceiverNeedURI()); Dataset messageContent = wonMessage.getMessageContent(); RDFNode score = findOnePropertyFromResource(messageContent, wonMessage.getMessageURI(), WON.HAS_MATCH_SCORE); if (!score.isLiteral()) return null; match.setScore(score.asLiteral().getDouble()); RDFNode counterpart = findOnePropertyFromResource(messageContent, wonMessage.getMessageURI(), WON.HAS_MATCH_COUNTERPART); if (!counterpart.isResource()) return null; match.setToNeed(URI.create(counterpart.asResource().getURI())); return match; }
@Override public void process(Exchange exchange) throws Exception { logger.debug("processing message for sending to remote node"); WonMessage wonMessage = (WonMessage) exchange.getIn().getHeader(WonCamelConstants.MESSAGE_HEADER); if (wonMessage.getSenderNeedURI() != null && wonMessage.getSenderNodeURI().equals(wonMessage.getReceiverNodeURI ())){ //sending locally, directly put message into the incoming need protocol messageService.sendInOnlyMessage(null, null, RdfUtils .writeDatasetToString(wonMessage.getCompleteDataset(), WonCamelConstants.RDF_LANGUAGE_FOR_MESSAGE), "activemq:queue:NeedProtocol.in"); return; } //add a camel endpoint for the remote won node needProtocolCommunicationService.configureCamelEndpoint(wonMessage.getReceiverNodeURI()); //send the message to that endpoint String ep = needProtocolCommunicationService.getProtocolCamelConfigurator().getEndpoint(wonMessage .getReceiverNodeURI()); //messageService.sendInOnlyMessage(null, null, wonMessage, wonMessage.getReceiverNodeURI().toString()); String msgBody = RdfUtils.writeDatasetToString(wonMessage.getCompleteDataset(), WonCamelConstants.RDF_LANGUAGE_FOR_MESSAGE); messageService.sendInOnlyMessage(null, null, msgBody, ep); }
public URI getMessageURI() { return message.getMessageURI(); }
private void checkNeedURI(final WonMessage message) { if (message.getMessageType() == WonMessageType.CREATE_NEED) { URI needURI = WonRdfUtils.NeedUtils.getNeedURI(message.getCompleteDataset()); Need need = needRepository.findOneByNeedURI(needURI); if (need == null) { return; } else { throw new UriAlreadyInUseException(message.getSenderNeedURI().toString()); } } return; }