@Test public void testInterceptMessageConstruction() throws Exception { MessageConstructionInterceptor interceptor = new AbstractMessageConstructionInterceptor() { @Override public boolean supportsMessageType(String messageType) { return MessageType.XML.toString().equalsIgnoreCase(messageType); } @Override protected Message interceptMessage( Message message, String messageType, TestContext context) { return new DefaultMessage("Intercepted!"); } @Override protected String getName() { return "MockInterceptor"; } }; Message in = new DefaultMessage("Hello Citrus!"); Message intercepted = interceptor.interceptMessageConstruction(in, MessageType.XML.toString(), context); Assert.assertEquals(intercepted.getPayload(String.class), "Intercepted!"); intercepted = interceptor.interceptMessageConstruction(in, MessageType.PLAINTEXT.toString(), context); Assert.assertEquals(intercepted.getPayload(String.class), "Hello Citrus!"); }
// ----------------------------------------------------------- public static GetFileReturnType getFileResponse(Socket s) throws GenericException { // GOELogger log = new GOELogger("/home/arbab/storageLogs/ws.log"); // System.out.println("INITIALIZED THE LOGGER"); GetFileReturnType r = new GetFileReturnType(); Message m = Message.receive(s); byte[] payload; // IP if (m.getMessageType() != MessageType.GET_FILE_RSP) throw new GenericException("Error, received invalid type: " + m.getMessageType()); else payload = m.getPayload(); r.IP = payload.toString(); System.out.println("IP: " + r.IP); // Port m = new Message(MessageType.SEND_NEXT_PARAM); try { m.send(s); } catch (IOException e) { throw new GenericException("error " + e); } m = Message.receive(s); if (m.getMessageType() != MessageType.NEXT_PARAM_RQT) { throw new GenericException("Error, received invalid type: " + m.getMessageType()); } else { payload = m.getPayload(); r.Port = (payload[0] << 8) + payload[1]; } // tid m = new Message(MessageType.SEND_NEXT_PARAM); try { m.send(s); } catch (IOException e) { throw new GenericException("error " + e); } m = Message.receive(s); if (m.getMessageType() != MessageType.NEXT_PARAM_RQT) { throw new GenericException("Error, received invalid type: " + m.getMessageType()); } else { payload = m.getPayload(); // r.tid = (long)(payload[0] << 24) + (long)(payload[1] << 16) + // (long)(payload[2] << 8) + (long)payload[3]; // log.write("%%%%%% " + (long)payload[0] + " " + (long)payload[1] + " " + // (long)payload[2] + " " + (long)payload[3] + "\n", false); // log.write( (0x000000FF & ((long)payload[0])) + "\n",false); // log.write( (0x000000FF & ((long)payload[1])) + "\n",false); // log.write( (0x000000FF & ((long)payload[2])) + "\n",false); // log.write( (0x000000FF & ((long)payload[3])) + "\n",false); r.tid = (0x000000FF & ((long) payload[0] << 24)) + (0x000000FF & ((long) payload[1] << 16)) + (0x000000FF & ((long) payload[2] << 8)) + (0x000000FF & ((long) payload[3])); } return r; }
@Override public void validateMessagePayload( Message receivedMessage, Message controlMessage, XmlMessageValidationContext validationContext, TestContext context) throws ValidationException { log.info("Start XML message validation"); try { if (validationContext.isSchemaValidationEnabled()) { validateXMLSchema(receivedMessage, validationContext); validateDTD(validationContext.getDTDResource(), receivedMessage); } validateNamespaces(validationContext.getControlNamespaces(), receivedMessage); validateMessageContent(receivedMessage, controlMessage, validationContext, context); if (controlMessage != null) { Assert.isTrue( controlMessage.getHeaderData().size() <= receivedMessage.getHeaderData().size(), "Failed to validate header data XML fragments - found " + receivedMessage.getHeaderData().size() + " header fragments, expected " + controlMessage.getHeaderData().size()); for (int i = 0; i < controlMessage.getHeaderData().size(); i++) { validateXmlHeaderFragment( receivedMessage.getHeaderData().get(i), controlMessage.getHeaderData().get(i), validationContext, context); } } log.info("XML message validation successful: All values OK"); } catch (ClassCastException e) { throw new CitrusRuntimeException(e); } catch (DOMException e) { throw new CitrusRuntimeException(e); } catch (LSException e) { throw new CitrusRuntimeException(e); } catch (IllegalArgumentException e) { log.error( "Failed to validate:\n" + XMLUtils.prettyPrint(receivedMessage.getPayload(String.class))); throw new ValidationException("Validation failed:", e); } catch (ValidationException ex) { log.error( "Failed to validate:\n" + XMLUtils.prettyPrint(receivedMessage.getPayload(String.class))); throw ex; } }
void deliverIncomingMessage(final Message message) { long mid = message.getMessageId(); long rmid = message.getRequestMessageId(); Object payload = null; Exception exception = null; if (message.getFlag() == Message.ERROR) { exception = (Exception) message.getPayload(); exception.printStackTrace(); } else { payload = message.getPayload(); } ipci.deliverIncomingMessage(message.getIPCHandle(), mid, rmid, payload, exception); }
public void send(Message message) { boolean rc; rc = sock.sendMore(message.getHeader()); if (!rc) assert (false); rc = sock.send(message.getPayload()); if (!rc) assert (false); }
// ----------------------------------------------------------- // --------------------HANDSHAKING FUNCTIONS------------------ public static byte[] transactionAddedResponse(Socket s) throws GenericException { Message m = Message.receive(s); if (m.getMessageType() == MessageType.TRANS_ADDED_RSP) { System.out.println(m.getPayload().toString()); // long tid = (long)(m.getPayload()[0]<<24) + // (long)(m.getPayload()[1]<<16) + (long)(m.getPayload()[2]<<8) + // (long)(m.getPayload()[3]); // if(m.getPayload().length > 4) { // } // return tid; return m.getPayload(); } else { System.out.println( "Error, got " + m.getMessageType() + " when " + MessageType.TRANS_ADDED_RSP + " was expected."); throw new GenericException(m.getMessageType().getDescription()); } }
// ----------------------------------------------------------- public static listFilesRequestType listFilesResponse(Socket s) throws GenericException { byte[] payload; int numFiles; Message m = Message.receive(s); if (m.getMessageType() != MessageType.LIST_FILES_RSP) throw new GenericException("Error, received invalid type: " + m.getMessageType()); else { payload = m.getPayload(); numFiles = (payload[0] << 24) + (payload[1] << 16) + (payload[2] << 8) + payload[3]; } System.out.println(numFiles + " files to be received"); listFilesRequestType fileList = new listFilesRequestType(numFiles); for (int i = 0; i < numFiles; i++) { // m.setMessageType(MessageType.SEND_NEXT_PARAM); m = new Message(MessageType.SEND_NEXT_PARAM); try { m.send(s); } catch (IOException e) { throw new GenericException("error " + e); } m = Message.receive(s); if (m.getMessageType() != MessageType.FILE_NAME_RQT && m.getMessageType() != MessageType.DIR_NAME_RQT) { throw new GenericException("Error, received invalid type: " + m.getMessageType()); } else { payload = m.getPayload(); fileList.name[i] = byteArrayToString(payload); if (m.getMessageType() == MessageType.FILE_NAME_RQT) { fileList.isDir[i] = false; System.out.println("File: " + fileList.name[i]); } else { fileList.isDir[i] = true; System.out.println("Directory: " + fileList.name[i]); } } } // end for return (fileList); }
/** * Validate message payloads by comparing to a control message. * * @param receivedMessage * @param validationContext * @param context */ protected void validateMessageContent( Message receivedMessage, Message controlMessage, XmlMessageValidationContext validationContext, TestContext context) { if (controlMessage == null || controlMessage.getPayload() == null) { log.info("Skip message payload validation as no control message was defined"); return; } if (!(controlMessage.getPayload() instanceof String)) { throw new IllegalArgumentException( "DomXmlMessageValidator does only support message payload of type String, " + "but was " + controlMessage.getPayload().getClass()); } String controlMessagePayload = controlMessage.getPayload(String.class); if (receivedMessage.getPayload() == null || !StringUtils.hasText(receivedMessage.getPayload(String.class))) { Assert.isTrue( !StringUtils.hasText(controlMessagePayload), "Unable to validate message payload - received message payload was empty, control message payload is not"); return; } else if (!StringUtils.hasText(controlMessagePayload)) { return; } log.info("Start XML tree validation ..."); Document received = XMLUtils.parseMessagePayload(receivedMessage.getPayload(String.class)); Document source = XMLUtils.parseMessagePayload(controlMessagePayload); XMLUtils.stripWhitespaceNodes(received); XMLUtils.stripWhitespaceNodes(source); if (log.isDebugEnabled()) { log.debug("Received message:\n" + XMLUtils.serialize(received)); log.debug("Control message:\n" + XMLUtils.serialize(source)); } validateXmlTree( received, source, validationContext, namespaceContextBuilder.buildContext(receivedMessage, validationContext.getNamespaces()), context); }
// ------------------------------------------------------------ private boolean respondToDatagram( DatagramPacket receivePacket, ServerDescription[] validServers, boolean addToFile, int expectedServers) throws IOException { boolean serverAdded = false; StorageServer serv = new StorageServer(); try { if (receivePacket.getData()[0] == MessageType.ADD_SERV_RQT.getType()) { extractPacketData(serv, receivePacket); int servNo = findServer(validServers, serv.IP, serv.port); int index = servAlreadyConnected(serv); /* * if(expectedServers == 0) { Message m = new * Message(MessageType.COPY_FILE_RQT); m.send(serv.sock); return(false); * } else if(expectedServers == 1) { Message m = new * Message(MessageType.COPY_FILE_RSP); m.send(serv.sock); return(false); * } else if(expectedServers == 2) { Message m = new * Message(MessageType.DELETE_DIR_RQT); m.send(serv.sock); * return(false); } else { Message m = new * Message(MessageType.DELETE_DIR_RSP); m.send(serv.sock); } * if(expectedServers > 2) { return false; } */ if (servNo > 0 || addToFile) { if (index >= 0) { System.out.println("Reconnection of a server, removing stale values"); serverList.remove(index); } Message m = new Message(MessageType.SEND_NEXT_PARAM); m.send(serv.sock); m = Message.receive(serv.sock); if (m.getMessageType() != MessageType.NEXT_PARAM_RQT) { m = new Message(MessageType.ERR_UNEXPECTED_CLT); m.send(serv.sock); return (false); } else { byte[] payload = new byte[2]; payload = m.getPayload(); serv.httpPort = payload[0] & 0xff; serv.httpPort <<= 8; serv.httpPort += payload[1] & 0xff; if (servNo > 0) { serv.servNo = servNo; } if (servNo < 0) { try { validServers[expectedServers].IP = ServerDescription.IPStrToByteArr(serv.IP); validServers[expectedServers].port = serv.port; validServers[expectedServers].serverNumber = findMinUnusedServNum(validServers); serv.servNo = validServers[expectedServers].serverNumber; addToFile(serv, validServers[expectedServers].serverNumber); serverAdded = true; } catch (GenericException e) { m = new Message(MessageType.ERR_UNEXPECTED_CLT); m.send(serv.sock); return (false); } } // By default, external IP = internal IP serv.externalName = serv.IP; Iterator itr = ipPairs.iterator(); // if we find an external IP that is associated with the // internal IP for this server, change the external IP // address for this server to match while (itr.hasNext()) { String[] pair = (String[]) itr.next(); // mylog.write("pair[0]: " + pair[0] + "servIP: " + serv.IP + // "\n", true); if (pair[0].equals(serv.IP)) { // mylog.write("found ext int match\n", true); serv.externalName = pair[1]; /* * Runtime runtime = Runtime.getRuntime(); String[] args = new * String[]{"sh", "-c", "ssh -f -i " + keyfile + " root@" + gwIP * + " \"perl stoptcppr.pl " + serv.externalIP + "\""}; Process * proc = runtime.exec(args); args = new String[]{"sh", "-c", * "ssh -f -i " + keyfile + " root@" + gwIP + * " \"perl tcppr.pl " + serv.externalIP + " " + serv.IP + * "\""}; proc = runtime.exec(args); */ break; } } serverList.add(serv); m = new Message(MessageType.ADD_SERV_RSP); payload[0] = (byte) ((servNo >> 8) & 0xff); payload[1] = (byte) (servNo & 0xff); m.addPayload(payload); m.send(serv.sock); } } else { Message m = new Message(MessageType.ERR_UNEXPECTED_CLT); m.send(serv.sock); } } return (serverAdded); } catch (IOException e) { Message m = new Message(MessageType.INTERNAL_SERVER_ERR); m.send(serv.sock); throw new IOException(e); } catch (GenericException e) { Message m = new Message(MessageType.INTERNAL_SERVER_ERR); m.send(serv.sock); throw new IOException(e.getMessage()); } }
public AbstractMessage(Message message) { this(message.getDescriptor(), message.getArguments()); this.messagePayload = message.getPayload(); }
/** * Validate namespaces in message. The method compares namespace declarations in the root element * of the received message to expected namespaces. Prefixes are important too, so differing * namespace prefixes will fail the validation. * * @param expectedNamespaces * @param receivedMessage */ protected void validateNamespaces( Map<String, String> expectedNamespaces, Message receivedMessage) { if (CollectionUtils.isEmpty(expectedNamespaces)) { return; } if (receivedMessage.getPayload() == null || !StringUtils.hasText(receivedMessage.getPayload(String.class))) { throw new ValidationException( "Unable to validate message namespaces - receive message payload was empty"); } log.info("Start XML namespace validation"); Document received = XMLUtils.parseMessagePayload(receivedMessage.getPayload(String.class)); Map<String, String> foundNamespaces = XMLUtils.lookupNamespaces(receivedMessage.getPayload(String.class)); if (foundNamespaces.size() != expectedNamespaces.size()) { throw new ValidationException( "Number of namespace declarations not equal for node " + XMLUtils.getNodesPathName(received.getFirstChild()) + " found " + foundNamespaces.size() + " expected " + expectedNamespaces.size()); } for (Entry<String, String> entry : expectedNamespaces.entrySet()) { String namespace = entry.getKey(); String url = entry.getValue(); if (foundNamespaces.containsKey(namespace)) { if (!foundNamespaces.get(namespace).equals(url)) { throw new ValidationException( "Namespace '" + namespace + "' values not equal: found '" + foundNamespaces.get(namespace) + "' expected '" + url + "' in reference node " + XMLUtils.getNodesPathName(received.getFirstChild())); } else { log.info( "Validating namespace " + namespace + " value as expected " + url + " - value OK"); } } else { throw new ValidationException( "Missing namespace " + namespace + "(" + url + ") in node " + XMLUtils.getNodesPathName(received.getFirstChild())); } } log.info("XML namespace validation finished successfully: All values OK"); }
/** * Validate message with a XML schema. * * @param receivedMessage * @param validationContext */ protected void validateXMLSchema( Message receivedMessage, XmlMessageValidationContext validationContext) { if (receivedMessage.getPayload() == null || !StringUtils.hasText(receivedMessage.getPayload(String.class))) { return; } try { Document doc = XMLUtils.parseMessagePayload(receivedMessage.getPayload(String.class)); if (!StringUtils.hasText(doc.getFirstChild().getNamespaceURI())) { return; } log.info("Starting XML schema validation ..."); XmlValidator validator = null; XsdSchemaRepository schemaRepository = null; if (validationContext.getSchema() != null) { validator = applicationContext .getBean(validationContext.getSchema(), XsdSchema.class) .createValidator(); } else if (validationContext.getSchemaRepository() != null) { schemaRepository = applicationContext.getBean( validationContext.getSchemaRepository(), XsdSchemaRepository.class); } else if (schemaRepositories.size() == 1) { schemaRepository = schemaRepositories.get(0); } else if (schemaRepositories.size() > 0) { for (XsdSchemaRepository repository : schemaRepositories) { if (repository.canValidate(doc)) { schemaRepository = repository; } } if (schemaRepository == null) { throw new CitrusRuntimeException( String.format( "Failed to find proper schema repository in Spring bean context for validating element '%s(%s)'", doc.getFirstChild().getLocalName(), doc.getFirstChild().getNamespaceURI())); } } else { log.warn( "Neither schema instance nor schema repository defined - skipping XML schema validation"); return; } if (schemaRepository != null) { if (!schemaRepository.canValidate(doc)) { throw new CitrusRuntimeException( String.format( "Unable to find proper XML schema definition for element '%s(%s)' in schema repository '%s'", doc.getFirstChild().getLocalName(), doc.getFirstChild().getNamespaceURI(), schemaRepository.getName())); } List<Resource> schemas = new ArrayList<>(); for (XsdSchema xsdSchema : schemaRepository.getSchemas()) { if (xsdSchema instanceof XsdSchemaCollection) { for (Resource resource : ((XsdSchemaCollection) xsdSchema).getSchemaResources()) { schemas.add(resource); } } else if (xsdSchema instanceof WsdlXsdSchema) { for (Resource resource : ((WsdlXsdSchema) xsdSchema).getSchemaResources()) { schemas.add(resource); } } else { synchronized (transformerFactory) { ByteArrayOutputStream bos = new ByteArrayOutputStream(); try { transformerFactory .newTransformer() .transform(xsdSchema.getSource(), new StreamResult(bos)); } catch (TransformerException e) { throw new CitrusRuntimeException( "Failed to read schema " + xsdSchema.getTargetNamespace(), e); } schemas.add(new ByteArrayResource(bos.toByteArray())); } } } validator = XmlValidatorFactory.createValidator( schemas.toArray(new Resource[schemas.size()]), WsdlXsdSchema.W3C_XML_SCHEMA_NS_URI); } SAXParseException[] results = validator.validate(new DOMSource(doc)); if (results.length == 0) { log.info("Schema of received XML validated OK"); } else { log.error( "Schema validation failed for message:\n" + XMLUtils.prettyPrint(receivedMessage.getPayload(String.class))); // Report all parsing errors log.debug("Found " + results.length + " schema validation errors"); StringBuilder errors = new StringBuilder(); for (SAXParseException e : results) { errors.append(e.toString()); errors.append("\n"); } log.debug(errors.toString()); throw new ValidationException("Schema validation failed:", results[0]); } } catch (IOException e) { throw new CitrusRuntimeException(e); } catch (SAXException e) { throw new CitrusRuntimeException(e); } }