public IotHubMessageResult execute(Message msg, Object context) {
Counter counter = (Counter) context;
System.out.println(
"Received message "
+ counter.toString()
+ " with content: "
+ new String(msg.getBytes(), Message.DEFAULT_IOTHUB_MESSAGE_CHARSET));
int switchVal = counter.get() % 3;
IotHubMessageResult res;
switch (switchVal) {
case 0:
res = IotHubMessageResult.COMPLETE;
break;
case 1:
res = IotHubMessageResult.ABANDON;
break;
case 2:
res = IotHubMessageResult.REJECT;
break;
default:
// should never happen.
throw new IllegalStateException("Invalid message result specified.");
}
System.out.println("Responding to message " + counter.toString() + " with " + res.name());
counter.increment();
return res;
}
public IotHubMessageResult execute(Message msg, Object context) {
Counter counter = (Counter) context;
System.out.println(
"Received message "
+ counter.toString()
+ " with content: "
+ new String(msg.getBytes(), Message.DEFAULT_IOTHUB_MESSAGE_CHARSET));
counter.increment();
return IotHubMessageResult.COMPLETE;
}
public static void main(String[] args) throws Exception {
System.out.println("Starting ClientPublisher sample");
if (args.length < 2 || args.length > 3) {
printHelp();
return;
}
String opcUrl = args[0];
String connString = args[1];
IotHubClientProtocol protocol = IotHubClientProtocol.AMQPS;
if (args.length > 2) {
String protocolStr = args[2].toLowerCase();
if (protocolStr.equals("https")) {
protocol = IotHubClientProtocol.HTTPS;
} else if (protocolStr.equals("amqps")) {
protocol = IotHubClientProtocol.AMQPS;
} else if (protocolStr.equals("mqtt")) {
protocol = IotHubClientProtocol.MQTT;
} else if (protocolStr.equals("amqps_ws")) {
protocol = IotHubClientProtocol.AMQPS_WS;
} else {
System.out.format("Protocol: %s not found, using AMQPS instead\n", protocolStr);
}
}
System.out.format("OPC Server: %s\n", opcUrl);
System.out.format("IoT Hub ConnectionString: %s\n", connString);
System.out.format("Start communication using protocol %s.\n", protocol.name());
////////////// CLIENT //////////////
// Load Client's Application Instance Certificate from file
KeyPair myClientApplicationInstanceCertificate = getOPCCert("ClientPublisher");
// Create Client
Client myClient = Client.createClientApplication(myClientApplicationInstanceCertificate);
////////// DISCOVER ENDPOINT /////////
// Discover server's endpoints, and choose one
String publicHostname = InetAddress.getLocalHost().getHostName();
EndpointDescription[] endpoints = myClient.discoverEndpoints(opcUrl);
// Filter out all but opc.tcp protocol endpoints
if (opcUrl.startsWith("opc.tcp")) {
endpoints = selectByProtocol(endpoints, "opc.tcp");
// Filter out all but Signed & Encrypted endpoints
endpoints = selectByMessageSecurityMode(endpoints, MessageSecurityMode.SignAndEncrypt);
// Filter out all but Basic128 cryption endpoints
endpoints = selectBySecurityPolicy(endpoints, SecurityPolicy.BASIC128RSA15);
// Sort endpoints by security level. The lowest level at the
// beginning, the highest at the end of the array
endpoints = sortBySecurityLevel(endpoints);
} else {
// we don't have a valid https cert for now
System.out.format("HTTPS protocol not suported.\n");
System.exit(0);
endpoints = selectByProtocol(endpoints, "https");
}
// Choose one endpoint
EndpointDescription endpoint = endpoints[endpoints.length - 1];
// fix connection issue on localhost
if (endpoint.getEndpointUrl().contains(publicHostname)) {
endpoint.setEndpointUrl(endpoint.getEndpointUrl().replace(publicHostname, "localhost"));
} else {
// fix .Net UA Server bug, patch localhost with hostname of server
if (endpoint.getEndpointUrl().contains("localhost")) {
URL opcURL = new URL(opcUrl.replace("opc.tcp", "http"));
endpoint.setEndpointUrl(endpoint.getEndpointUrl().replace("localhost", opcURL.getHost()));
}
}
////////////////////// AZURE IotHub ////////////////////////////
// connect to Azure IotHub with connection string and protocol
// see http://www.github.com/Azure/azure-iot-sdks/java
//
DeviceClient client = new DeviceClient(connString, protocol);
System.out.println("Successfully created an IoT Hub client.");
if (protocol == IotHubClientProtocol.MQTT) {
MessageCallbackMqtt callback = new MessageCallbackMqtt();
Counter counter = new Counter(0);
client.setMessageCallback(callback, counter);
} else {
MessageCallback callback = new MessageCallback();
Counter counter = new Counter(0);
client.setMessageCallback(callback, counter);
}
System.out.println("Successfully set message callback.");
client.open();
System.out.println("Opened connection to IoT Hub.");
System.out.println("Beginning to receive messages...");
//////////// SESSION ////////////
// Create Session
SessionChannel mySession = myClient.createSessionChannel(endpoint);
mySession.activate();
System.out.println("Opened session to OPC Server.");
///////////// EXECUTE //////////////
// Browse Root
BrowseDescription browse = new BrowseDescription();
browse.setNodeId(Identifiers.RootFolder);
browse.setBrowseDirection(BrowseDirection.Forward);
browse.setIncludeSubtypes(true);
browse.setNodeClassMask(NodeClass.Object, NodeClass.Variable);
browse.setResultMask(BrowseResultMask.All);
BrowseResponse browseResponse = mySession.Browse(null, null, null, browse);
System.out.println(browseResponse);
///////////// PUBLISH /////////////
// Poll OPC server and publish to Azure IotHub
int count = 0;
while (count++ < 100) {
// Read current time
NodeId nodeId = Identifiers.Server_ServerStatus_CurrentTime;
ReadResponse opcCurrentTime =
mySession.Read(
null,
500.0,
TimestampsToReturn.Both,
new ReadValueId(nodeId, Attributes.Value, null, null));
// convert node to JSON
JSONObject obj = new JSONObject();
obj.put("Id", nodeId.toString());
obj.put("Uri", endpoints[0].getServer().getApplicationUri());
JSONObject value = new JSONObject();
value.put("Value", opcCurrentTime.getResults()[0].getValue().toString());
value.put("SourceTimestamp", opcCurrentTime.getResults()[0].getSourceTimestamp().toString());
value.put("ServerTimestamp", opcCurrentTime.getResults()[0].getServerTimestamp().toString());
JSONObject monitoredItem = new JSONObject();
monitoredItem.put("MonitoredItem", obj);
monitoredItem.put("ClientHandle", 2);
monitoredItem.put("Value", value);
// publish JSON string to IotHub
String msgStr = monitoredItem.toString();
try {
Message msg = new Message(msgStr);
msg.setProperty("messageCount", Integer.toString(count));
msg.setExpiryTime(5000);
System.out.println(msgStr);
EventCallback eventCallback = new EventCallback();
client.sendEventAsync(msg, eventCallback, count);
} catch (Exception e) {
e.printStackTrace();
}
try {
System.out.println(opcCurrentTime);
System.out.println(msgStr);
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
///////////// SHUTDOWN /////////////
mySession.close();
mySession.closeAsync();
//////////////////////////////////////
client.close();
//////////////////////////////////////
System.exit(0);
}