@Test
public void structuredAndUnstructuredOptions() throws Exception {
// From https://developers.google.com/protocol-buffers/docs/proto#options
Schema schema =
new SchemaBuilder()
.add(
"foo.proto",
""
+ "import \"google/protobuf/descriptor.proto\";\n"
+ "message FooOptions {\n"
+ " optional int32 opt1 = 1;\n"
+ " optional string opt2 = 2;\n"
+ "}\n"
+ "\n"
+ "extend google.protobuf.FieldOptions {\n"
+ " optional FooOptions foo_options = 1234;\n"
+ "}\n"
+ "\n"
+ "message Bar {\n"
+ " optional int32 a = 1 [(foo_options).opt1 = 123, (foo_options).opt2 = \"baz\"];\n"
+ " optional int32 b = 2 [(foo_options) = { opt1: 456 opt2: \"quux\" }];\n"
+ "}\n")
.add("google/protobuf/descriptor.proto")
.build();
ProtoMember fooOptions = ProtoMember.get(Options.FIELD_OPTIONS, "foo_options");
ProtoMember opt1 = ProtoMember.get(ProtoType.get("FooOptions"), "opt1");
ProtoMember opt2 = ProtoMember.get(ProtoType.get("FooOptions"), "opt2");
MessageType bar = (MessageType) schema.getType("Bar");
assertThat(bar.field("a").options().map())
.isEqualTo(ImmutableMap.of(fooOptions, ImmutableMap.of(opt1, "123", opt2, "baz")));
assertThat(bar.field("b").options().map())
.isEqualTo(ImmutableMap.of(fooOptions, ImmutableMap.of(opt1, "456", opt2, "quux")));
}
public static MessageType getMessageType(String description) {
if (null == description) return null;
for (MessageType _enum : MessageType.values()) {
if (description.equals(_enum.getDescription())) return _enum;
}
return null;
}
public static MessageType getMessageType(Integer value) {
if (null == value) return null;
for (MessageType _enum : MessageType.values()) {
if (value.equals(_enum.getValue())) return _enum;
}
return null;
}
/**
* The geoprocessing message type.
*
* @return MessageType
*/
public final MessageType getType() {
String t = _getType();
for (int i = 0; i < MessageType.values().length; i++) {
if (MessageType.values()[i].getValue().contentEquals(t)) return MessageType.values()[i];
}
return null;
}
public List<WebElement> getUpdatedMsgState(MessageType messageType) throws Exception {
WebElement messagesTable = service.findElement(tableLocator);
if (messageType.equals(MessageType.AGENT)) {
return messagesTable.findElements(agentLineLocator);
} else if (messageType.equals(MessageType.VISITOR)) {
return messagesTable.findElements(visitorLineLocator);
}
return null;
}
// -----------------------------------------------------------
// receive a terminateResponse message
public static void terminateResponse(Socket s) throws GenericException {
Message m = Message.receive(s);
MessageType t = m.getMessageType();
if (t == MessageType.TERM_RSP) return;
else if (t == MessageType.TERM_ERR) throw new GenericException(t.getDescription());
else if (t.isErrorType())
throw new GenericException("Server encountered an " + t.getDescription());
else throw new GenericException("Server's response is of an unexpected type.");
}
// -----------------------------------------------------------
// receive an initResponse message
public static void initResponse(Socket s) throws GenericException {
System.out.println("Receiving init");
Message m = Message.receive(s);
System.out.println("Init received");
MessageType t = m.getMessageType();
if (t == MessageType.INIT_RSP) return;
else if (t.isErrorType())
throw new GenericException("Server encountered an " + t.getDescription());
else throw new GenericException("Server's response is of an unexpected type: " + t.name());
}
private void initMessage() {
apply.setText(constants.Apply());
if (messageType.equals(MessageType.ERROR)) {
imageMessage.setResource(images.error());
} else if (messageType.equals(MessageType.INFO)) {
imageMessage.setResource(images.information());
} else if (messageType.equals(MessageType.WARNING)) {
imageMessage.setResource(images.warning());
} else {
imageMessage.setResource(images.information());
}
}
@Test
public void testIDs() throws Exception {
MessageType schema =
new MessageType(
"test",
new PrimitiveType(REQUIRED, BINARY, "foo").withId(4),
new GroupType(REQUIRED, "bar", new PrimitiveType(REQUIRED, BINARY, "baz").withId(3))
.withId(8));
MessageType schema2 = MessageTypeParser.parseMessageType(schema.toString());
assertEquals(schema, schema2);
assertEquals(schema.toString(), schema2.toString());
}
private void processMessage(Message message) throws IOException {
if (message.getType().equals("SimpleMessage")) {
MessageType messageType = (MessageType) message.getValue();
String receiver = messageType.getToUser();
history.get(receiver).add(messageType);
}
if (message.getType().equals("ConnectUserMessage")) {
String user = (String) message.getValue();
Messages messages = history.get(user);
Operations.sendHistory(messages.getLastFiveWith(user), out);
}
}
private Message parseMessage(ChannelBuffer buffer, int length) {
for (int commandLength = 4; commandLength <= length; commandLength++) {
String command =
buffer.toString(buffer.readerIndex(), commandLength, Charset.forName("US-ASCII"));
Log.df("command: {0}", command);
MessageType type = MessageType.getByCommand(command);
if (type != null) {
buffer.readerIndex(buffer.readerIndex() + commandLength);
return new Message(type, type.parse(buffer));
}
}
Log.d("null message");
return null;
}
Map<ProtoMember, Object> canonicalizeOption(
Linker linker, ProtoType extensionType, OptionElement option) {
Type type = linker.get(extensionType);
if (!(type instanceof MessageType)) {
return null; // No known extensions for the given extension type.
}
MessageType messageType = (MessageType) type;
String[] path;
Field field = messageType.field(option.name());
if (field != null) {
// This is an option declared by descriptor.proto.
path = new String[] {option.name()};
} else {
// This is an option declared by an extension.
Map<String, Field> extensionsForType = messageType.extensionFieldsMap();
path = resolveFieldPath(option.name(), extensionsForType.keySet());
String packageName = linker.packageName();
if (path == null && packageName != null) {
// If the path couldn't be resolved, attempt again by prefixing it with the package name.
path = resolveFieldPath(packageName + "." + option.name(), extensionsForType.keySet());
}
if (path == null) {
return null; // Unable to find the root of this field path.
}
field = extensionsForType.get(path[0]);
}
Map<ProtoMember, Object> result = new LinkedHashMap<>();
Map<ProtoMember, Object> last = result;
ProtoType lastProtoType = messageType.type();
for (int i = 1; i < path.length; i++) {
Map<ProtoMember, Object> nested = new LinkedHashMap<>();
last.put(ProtoMember.get(lastProtoType, field), nested);
lastProtoType = field.type();
last = nested;
field = linker.dereference(field, path[i]);
if (field == null) {
return null; // Unable to dereference this path segment.
}
}
last.put(
ProtoMember.get(lastProtoType, field), canonicalizeValue(linker, field, option.value()));
return result;
}
/**
* Handles server noninvite message
*
* @param msg - noninvite message
*/
public void handleIncomingBye(final Request msg) {
assert TransactionUtils.isTransactionExecutionThread()
: "Code run in wrong thread. Must be run in TransactionThread. Now in "
+ Thread.currentThread();
assert !done.get();
assert msg != null && MessageType.SIP_BYE == MessageType.parse(msg.getMethod());
Logger.log("Remote party has sent noninvite");
if (!done.get()) {
final Dialog dialog = getStackContext().getDialogStorage().findDialogForMessage(msg);
assert dialog != null;
assert STATED == dialog.getState();
dialog.getMessageHistory().addMessage(msg, true);
final TransactionManager transactionManager = getTransactionManager();
transactionManager.addListener(
new FirstMessageResolver(SIP_BYE_SERVER.getName(), dialog, msg, transactionManager));
final Transaction transaction =
transactionManager.lookUpTransaction(dialog, null, SIP_BYE_SERVER);
runAsynchronously(transaction, TRANSACTION_TIMEOUT);
}
}
/** Builds a NetworkMessage of the correct type */
public static NetworkMessage getMessage(String fromIP, String strMessage) {
String[] messageArgs = strMessage.trim().split(";");
MessageType messageType = MessageType.values()[Integer.parseInt(messageArgs[0])];
String[] remainingArgs = Utils.arrayCopy(messageArgs, 1, messageArgs.length);
NetworkMessage message = null;
switch (messageType) {
case Command:
message = new NetworkCommand(fromIP, remainingArgs);
break;
case Heartbeat:
message = new Heartbeat(fromIP, remainingArgs);
break;
case TextMessage:
message = new TextMessage(fromIP, remainingArgs);
break;
case ShuttingDown:
message = new NetworkMessage(fromIP, remainingArgs);
break;
default:
System.err.println("Receieved unknown message type. Message: " + strMessage);
}
message.rcvdTime = System.currentTimeMillis();
return message;
}
// -----------------------------------------------------------
public static void getPutFileRequest(Socket s, String[] args, int numArgs, byte type)
throws GenericException {
byte[] myPayload = new byte[4];
myPayload[0] = (byte) ((numArgs >> 24) & 0xff);
myPayload[1] = (byte) ((numArgs >> 16) & 0xff);
myPayload[2] = (byte) ((numArgs >> 8) & 0xff);
myPayload[3] = (byte) (numArgs & 0xff);
Message m = new Message(MessageType.findType(type));
m.addPayload(myPayload);
try {
m.send(s);
m = Message.receive(s);
if (m.getMessageType() != MessageType.SEND_NEXT_PARAM) {
System.out.println("Error, unexpected type returned");
throw new GenericException("Received wrong type");
}
} catch (IOException e) {
throw new GenericException(e.getMessage());
}
try {
sendArgs(s, args, numArgs, MessageType.NEXT_PARAM_RQT);
} catch (GenericException e) {
throw new GenericException("Error " + e);
}
}
/**
* Handles server invite message
*
* @param msg - invite message
*/
public void handleIncomingInvite(final Request msg) throws DialogStateException {
assert TransactionUtils.isTransactionExecutionThread()
: "Code run in wrong thread. Must be run in TransactionThread. Now in "
+ Thread.currentThread();
assert !done.get();
assert msg != null && MessageType.SIP_INVITE == MessageType.parse(msg.getMethod());
if (!done.get()) {
Logger.log("Remote party has sent invite");
// ClientIdentity localParty =
// getStackContext().getStackClientRegistry().findAddressee(msg.getTo().getUriBuilder().getShortURI());
ClientIdentity localParty = getStackContext().getClientRouter().findAddressee(msg);
if (localParty != null) {
assert getStackContext().getDialogStorage().findDialogForMessage(msg) == null;
final Dialog dialog =
getStackContext().getDialogStorage().getDialogForIncomingMessage(localParty, msg);
TransactionType<InviteSrvTransaction, ? extends ServerCommonInviteTransaction>
transactionType = SIP_INVITE_SERVER;
doHandleIncomingInvite(msg, dialog, transactionType);
} else {
throw new DialogStateException(null, DialogStateException.Error.ADDRESSEE_NOT_FOUND, msg);
}
}
}
@Override
public void writeStats(MessageType message) {
XMLEventFactory eventFactory = XMLEventFactory.newInstance();
XMLEvent end = eventFactory.createDTD("\n");
XMLEvent tab = eventFactory.createDTD("\t");
// Create Start node
List<Attribute> attrs = new LinkedList<Attribute>();
attrs.add(eventFactory.createAttribute(REQUEST_NUM_ATTR_NAME, "" + countLine++));
for (Stat stat : message.getValues()) {
attrs.add(eventFactory.createAttribute(stat.getKey(), "" + stat.getValue()));
}
final Iterator<Attribute> attrIt = attrs.iterator();
StartElement sElement =
eventFactory.createStartElement(
"", "", REQUEST_ELEMENT_NAME, attrIt, Collections.<Namespace>emptyList().iterator());
try {
eventWriter.add(tab);
eventWriter.add(sElement);
// Create End node
EndElement eElement = eventFactory.createEndElement("", "", REQUEST_ELEMENT_NAME);
eventWriter.add(eElement);
eventWriter.add(end);
} catch (XMLStreamException e) {
throw new RuntimeException("ERROR IN WRITING XML: ", e);
}
}
/**
* Parse message type.
*
* @param value the value
* @return the message type
*/
public static MessageType parse(final byte value) {
for (MessageType c : MessageType.values()) {
if (c.value == value) {
return c;
}
}
throw new IllegalArgumentException("Unexpected value " + value);
}
public static MessageType getFromValue(String value) {
for (MessageType e : MessageType.values()) {
if (e.value.equals(value)) {
return e;
}
}
return null;
}
@Override
public int hashCode() {
int result = sessionId.hashCode();
result = 31 * result + guid.hashCode();
result = 31 * result + timestamp.hashCode();
result = 31 * result + messageType.hashCode();
return result;
}
public ChatMessage(Parcel in) {
this.id = in.readInt();
this.msgid = in.readString();
this.contactId = in.readInt();
this.messageText = in.readString();
this.messageType = MessageType.parse(in.readInt());
this.messageSendStatus = MessageSendStatus.parse(in.readInt());
this.messageReadStatus = MessageReadStatus.parse(in.readInt());
this.sendTime = in.readLong();
this.deliveredTime = in.readLong();
this.receiveTime = in.readLong();
this.createTime = in.readLong();
}
@Test
public void testNestedTypes() {
MessageType schema = MessageTypeParser.parseMessageType(Paper.schema.toString());
Type type = schema.getType("Links", "Backward");
assertEquals(PrimitiveTypeName.INT64, type.asPrimitiveType().getPrimitiveTypeName());
assertEquals(0, schema.getMaxRepetitionLevel("DocId"));
assertEquals(1, schema.getMaxRepetitionLevel("Name"));
assertEquals(2, schema.getMaxRepetitionLevel("Name", "Language"));
assertEquals(0, schema.getMaxDefinitionLevel("DocId"));
assertEquals(1, schema.getMaxDefinitionLevel("Links"));
assertEquals(2, schema.getMaxDefinitionLevel("Links", "Backward"));
}
public String toString() {
StringBuffer buffer = new StringBuffer();
buffer
.append("[")
.append(senderUId)
.append("," + round)
.append("," + distance)
.append("," + type.toString())
.append("," + direction.toString())
.append("]")
.append(nodesTouched.toString())
.append("" + timestamp);
return buffer.toString();
}
public static EventMessage create(Map<String, Object> map) throws Exception {
EventMessage message = null;
String event = map.get("Event").toString();
if (event.equals("LOCATION")) {
LocationEvent locationEvent = new LocationEvent();
locationEvent.setLatitude(Double.parseDouble(map.get("Latitude").toString()));
locationEvent.setLongitude(Double.parseDouble(map.get("Longitude").toString()));
locationEvent.setPrecision(Float.parseFloat(map.get("Precision").toString()));
message = locationEvent;
} else if (event.equals("subscribe")) {
SubscribeEvent subscribeEvent = new SubscribeEvent();
message = subscribeEvent;
} else if (event.equals("CLICK")) {
ClickEvent mentEvent = new ClickEvent();
mentEvent.setEventKey(map.get("EventKey").toString());
message = mentEvent;
} else if (event.equals("scancode_waitmsg")) {
ScancodeWaitEvent scancodeWaitEvent = new ScancodeWaitEvent();
scancodeWaitEvent.setEventKey(map.get("EventKey").toString());
Map<String, Object> scanCodeInfoMap = (Map<String, Object>) map.get("ScanCodeInfo");
ScanCodeInfo scanCodeInfo = new ScanCodeInfo();
scanCodeInfo.setScanType(scanCodeInfoMap.get("ScanType").toString());
scanCodeInfo.setScanResult(scanCodeInfoMap.get("ScanResult").toString());
scancodeWaitEvent.setScanCodeInfo(scanCodeInfo);
message = scancodeWaitEvent;
} else if (event.equals("unsubscribe")) {
UnSubscribeEvent unsubscribeEvent = new UnSubscribeEvent();
message = unsubscribeEvent;
} else if (event.equals("VIEW")) {
ViewEvent mentEvent = new ViewEvent();
mentEvent.setEventKey(map.get("EventKey").toString());
message = mentEvent;
} else if (event.equals("SCAN")) {
QrEvent qrEvent = new QrEvent();
qrEvent.setEventKey(map.get("EventKey").toString());
qrEvent.setTicket(map.get("Ticket").toString());
message = qrEvent;
} else {
throw new Exception("Unsupported message.");
}
message.setEvent(event);
message.setToUserName(map.get("ToUserName").toString());
message.setFromUserName(map.get("FromUserName").toString());
message.setCreateTime(Long.parseLong(map.get("CreateTime").toString()));
message.setMsgType(MessageType.create(map.get("MsgType").toString()));
return message;
}
public static Message parseMessage(String msgStr) {
String[] msgParts = msgStr.split(MESSAGE_FIELDS_SEPARATOR + "");
int originatorId = Integer.parseInt(msgParts[0].split(MESSAGE_ID_SEPARATOR + "")[0]);
int label = Integer.parseInt(msgParts[0].split(MESSAGE_ID_SEPARATOR + "")[1]);
Message msg =
new Message(
originatorId,
label,
MessageType.valueOf(msgParts[1]),
Integer.parseInt(msgParts[2]),
msgParts[3]);
msg.setInstanceId(Integer.parseInt(msgParts[4]));
return msg;
}
public Description getSellerProtocol() {
Description pd = new Description();
// 0
TryNode tn = new TryNode();
pd.getNode().add(tn);
tn.setNextIndex(4);
tn.setInnerIndex(1);
tn.getCatchIndex().add(3);
// 1
ReceiveMessage recvOrder = new ReceiveMessage();
recvOrder.setNextIndex(2);
MessageType mt1 = new MessageType();
mt1.setValue(ORDER_MESSAGE_TYPE);
recvOrder.getMessageType().add(mt1);
pd.getNode().add(recvOrder);
// 2
SendMessage sendConformation = new SendMessage();
MessageType mt2 = new MessageType();
mt2.setValue(CONFIRMATION_MESSAGE_TYPE);
sendConformation.getMessageType().add(mt2);
pd.getNode().add(sendConformation);
// 3
ReceiveMessage recvCancel = new ReceiveMessage();
MessageType mt3 = new MessageType();
mt3.setValue(CANCEL_MESSAGE_TYPE);
recvCancel.getMessageType().add(mt3);
pd.getNode().add(recvCancel);
// 4
ReceiveMessage recvFinish = new ReceiveMessage();
MessageType mt4 = new MessageType();
mt4.setValue(FINISH_MESSAGE_TYPE);
recvFinish.getMessageType().add(mt4);
pd.getNode().add(recvFinish);
return (pd);
}
@Parameters(name = "Type:{0}; ReduceMemoryFootPrint:{1}; ConcurrentDispatch:{2}; UseTopic:{3}")
public static Collection<Object[]> data() {
List<Object[]> values = new ArrayList<>();
for (MessageType mt : MessageType.values()) {
for (boolean rmfVal : reduceMemoryFootPrintVals) {
for (boolean cdVal : concurrentDispatchVals) {
for (boolean tpVal : useTopicVals) {
values.add(new Object[] {mt, rmfVal, cdVal, tpVal});
}
}
}
}
return values;
}
/**
* Encode a simple UA TCP message.
*
* @param messageType {@link MessageType#Hello}, {@link MessageType#Acknowledge}, or {@link
* MessageType#Error}.
* @param messageEncoder a function that encodes the message payload.
* @param buffer the {@link ByteBuf} to encode into.
*/
private static ByteBuf encode(
MessageType messageType, Consumer<ByteBuf> messageEncoder, ByteBuf buffer)
throws UaException {
buffer.writeMedium(MessageType.toMediumInt(messageType));
buffer.writeByte('F');
int lengthIndex = buffer.writerIndex();
buffer.writeInt(0);
int indexBefore = buffer.writerIndex();
messageEncoder.accept(buffer);
int indexAfter = buffer.writerIndex();
int bytesWritten = indexAfter - indexBefore;
buffer.writerIndex(lengthIndex);
buffer.writeInt(8 + bytesWritten);
buffer.writerIndex(indexAfter);
return buffer;
}
public void handleIncomingCancel(Request msg) throws DialogStateException {
assert !done.get();
assert msg != null && MessageType.SIP_CANCEL == MessageType.parse(msg.getMethod());
if (!done.get()) {
Logger.log("Remote party has sent SIP_CANCEL");
final Dialog dialog = getStackContext().getDialogStorage().findDialogForMessage(msg);
if (dialog != null) {
dialog.getMessageHistory().addMessage(msg, true);
final InviteSrvTransaction transaction =
getTransactionManager().findTransaction(dialog, SIP_INVITE_SERVER);
if (transaction != null) {
final DialogStateEvent<BaseSipMessage> stateEvent =
new DefaultDialogStateEvent<BaseSipMessage>(
dialog, SessionState.SESSION_TERMINATED, msg);
dialogStateListenerHolder.getNotifier().onSessionTerminated(stateEvent);
dialogStateListenerHolder.getNotifier().onSessionEnded(stateEvent);
// DIALOG.putCustomParameter(ParamKey.INITIAL_MESSAGE, ((Transaction)
// transaction).getInitialMessage());
transaction.cancel();
} else {
// assert false : "Transaction already terminated for msg: " + msg.shortDescription() + "
// dialog: " + dialog;
throw new DialogStateException(
dialog, DialogStateException.Error.REQUEST_FOR_UNKNOWN_DIALOG, msg);
}
} else {
// assert false : "Dialog is already terminated or never exist. Message :" +
// msg.shortDescription();
throw new DialogStateException(
dialog, DialogStateException.Error.REQUEST_FOR_UNKNOWN_DIALOG, msg);
}
}
}
public void handleIncomingReInvite(final Request msg) throws DialogStateException {
assert TransactionUtils.isTransactionExecutionThread()
: "Code run in wrong thread. Must be run in TransactionThread. Now in "
+ Thread.currentThread();
assert !done.get();
assert msg != null && MessageType.SIP_INVITE == MessageType.parse(msg.getMethod());
if (!done.get()) {
Logger.log("Remote party has sent ReInvite");
final Dialog dialog = getStackContext().getDialogStorage().findDialogForMessage(msg);
assert dialog != null;
checkReInvitePreconditions(dialog, msg);
dialog.markReInviteInProgress(InitiateParty.REMOTE);
TransactionType<InviteSrvTransaction, ? extends ServerCommonInviteTransaction>
transactionType = SIP_REINVITE_SERVER;
doHandleIncomingInvite(msg, dialog, transactionType);
}
}
