We will follow up with the message arrivals a bit later, once we deal with the heartbeat
itself.
Sending the Client’s Heartbeats
To send the client’s heartbeats, you need a class to represent the heartbeat and a pro-
ducer to perform the sending.
The heartbeat message object will leverage available Flex/Java serialization—therefore,
you’ll need to come up with a pair of almost identical classes: one in Java and the other
one in ActionScript. The corresponding classes are presented in Examples 5-1 and
5-2. Notice the array 
received
, which will eventually carry delivery confirmations of
the latest received messages.
Example 5-1. ClientHeartbeatMessage.as
package com.farata.messaging.messages {
import mx.messaging.messages.AbstractMessage;
public  class ClientHeartbeatMessage
extends mx.messaging.messages.AbstractMessage {
public var received:Array; //Messages arrived since last heartbeat
public function ClientHeartbeatMessage() {
super();
//TODO - populate array "received" - later...
}
}
}
Example 5-2. ClientHeartbeatMessage.java
package com.farata.messaging.messages;
import flex.messaging.messages.AbstractMessage;
public class ClientHeartbeatMessage extends AbstractMessage {
public String[] received; // Array of <ClientID>|<MsgNumber> strings
}
To periodically send the heartbeat message (Example 5-1) up to the server you need a
Flex 
Producer
class powered with a 
Timer
Example 5-3 illustrates the custom
ClientHeartbeatProducer
class with the 
startHeartbeat()
and 
stopHeartbeat()
meth-
ods. By default, the heartbeat is sent to the server-side destination 
ClientHeartbeat
every second.
Example 5-3. ClientHeartbeatProducer
package com.farata.messaging.qos {
import com.farata.messaging.messages.ClientHeartbeatMessage;
Sending the Client’s Heartbeats s | | 217
.Pdf to .jpg converter online - Convert PDF to JPEG images in C#.net, ASP.NET MVC, WinForms, WPF project
How to convert PDF to JPEG using C#.NET PDF to JPEG conversion / converter library control SDK
batch pdf to jpg online; change file from pdf to jpg on
.Pdf to .jpg converter online - VB.NET PDF Convert to Jpeg SDK: Convert PDF to JPEG images in vb.net, ASP.NET MVC, WinForms, WPF project
Online Tutorial for PDF to JPEG (JPG) Conversion in VB.NET Image Application
best pdf to jpg converter for; best way to convert pdf to jpg
import flash.utils.clearInterval;
import flash.utils.setInterval;
import mx.messaging.Producer;
public class ClientHeartbeatProducer extends Producer {
public function ClientHeartbeatProducer() {
super();
destination = "clientHeartbeat";
}
public function startHeartbeat( destination:String=null,
interval:int=1000) : void {
if (connected)   this.stopHeartbeat();
if (destination != null) {
this.destination = destination;
}
connect();
// The next line can be implemented using Timer class
processId = setInterval( sendHeartbeat, interval);
}
public function stopHeartbeat() : void {
clearInterval(processId);
}
private var processId:int;
private function sendHeartbeat(): void {
send(new ClientHeartbeatMessage());
}
}
}
Note the property 
connected
defined in the grandparent of 
Producer
(
MessageAgent
); it
indicates whether this producer is currently connected to its destination. The function
sendHeartbeat()
will be called multiple times per a specified interval. In this version,
the instance of the 
ClientHeartBeatMessage
doesn’t carry any meaningful information
about the specific message being acknowledged.
The heartbeat is being sent—time to look at the receiving end: the server-side Java code.
Heartbeat Adapter
The client sends heartbeats; we need to decide where the right place in the Java server
is to intercept these messages. Both the LCDS and BlazeDS architectures provide two
logical points to do it: the adapter and the endpoint. The endpoint is a server-side class
that receives the message (see 
MessageService
in Example 5-4) and then forwards it for
processing to 
MessageBroker
, which in turns forwards it to the adapter. Theoretically,
if you want to introduce the server-side custom processing into this chain, override
either the endpoint or the adapter class.
218 | | Chapter 5: Customizing the Messaging Layer of LCDS or BlazeDS
Online Convert PDF to Jpeg images. Best free online PDF JPEG
Online PDF to JPEG Converter. Download Free Trial. Convert a PDF File to JPG. Drag and drop your PDF in the box above and we'll convert the files for you.
convert pdf into jpg format; convert online pdf to jpg
Online Convert Jpeg to PDF file. Best free online export Jpg image
Online JPEG to PDF Converter. Download Free Trial. Convert a JPG to PDF. You can drag and drop your JPG file in the box, and then start
changing pdf file to jpg; convert multipage pdf to jpg
In our case, the messages are originated on the server and we found empirically that
the endpoint doesn’t participate in this flow. That’s why we decided to customize the
adapter class. Later in this chapter, while customizing the client side of the messaging,
we’ll show you how to customize the endpoint.
By default, the 
ActionScriptAdapter
is used for messaging. If you are planning to inte-
grate with third-party middleware via the Java Messaging API, use 
JMSAdapter
.
You can read about messaging architecture in the document called the
BlazeDS Developer Guide. If you use LCDS, refer to the LiveCycle Data
Services ES documentation.
Example 5-4 illustrates that clientHeartbeat, a default heartbeat destination, is config-
ured in messaging-config.xml with the custom adapter—
com.farata.messag
ing.adapters.HeartbeatAdapter
. We’ll review it next.
Example 5-4. Heartbeat destination with custom heartbeat adapter
<?xml version="1.0" encoding="UTF-8"?>
<service id="message-service"
class="flex.messaging.services.MessageService">
<adapters>
<adapter-definition
id="actionscript" default="true"
class="flex.messaging.services.messaging.adapters.
ActionScriptAdapter"/>
<adapter-definition id="jms"
class="flex.messaging.services.messaging.adapters.
JMSAdapter"/>
<adapter-definition
id="heartbeat"
class="com.farata.messaging.adapters.HeartbeatAdapter"/>
</adapters>
<default-channels>
<channel ref="my-rtmp" />
</default-channels>
<destination id="clientHeartbeat">
<adapter ref="heartbeat"/>
<channels>
<channel ref="my-rtmp" />
</channels>
</destination>
</service>
Writing custom adapters is not terribly complicated: extend the 
MessagingAdapter
class and override the method 
invoke()
Example 5-5 presents our custom
Heartbeat Adapter r | 219
C# Image Convert: How to Convert Adobe PDF to Jpeg, Png, Bmp, &
using RasterEdge.XDoc.Converter; String inputFilePath = @"C:\input.pdf"; String outputFilePath = @"C:\output.jpg"; // Convert PDF to jpg.
convert pdf picture to jpg; best pdf to jpg converter
C# Image Convert: How to Convert Dicom Image File to Raster Images
RasterEdge.XDoc.PDF.dll. using RasterEdge.XDoc.Converter; String inputFilePath = @"C:\input.dcm"; String outputFilePath = @"C:\output.jpg"; // Convert dicom to
pdf to jpeg converter; change file from pdf to jpg
HeartbeatAdapter
. The callback 
invoke()
is being called when a client sends a message
to the destination.
As per the BlazeDS Developer Guide, a typical 
invoke()
method looks as follows:
public Object invoke(Message message) {
MessageService msgService = (MessageService)service;
msgService.pushMessageToClients(message, true);
msgService.sendPushMessageFromPeer(message, true);
return null;
}
For this exercise, we don’t need to push the message to clients or send it to the peer
servers in a cluster. Instead, we merely log the incoming message just to prove that
we’re getting it. A little later we’ll write a more meaningful adapter in which the client’s
heartbeat will learn how to carry some useful payload.
Example 5-5. Separating transfer of byte code from loading into stage
package com.farata.messaging.adapter;
import org.apache.log4j.Logger;
import com.farata.messaging.messages.ClientHeartbeatMessage;
import flex.messaging.messages.Message;
import flex.messaging.services.MessageService;
import flex.messaging.services.messaging.adapters.MessagingAdapter;
public class HeartbeatAdapter extends MessagingAdapter{
public Object invoke(Message message){
if ( message instanceof ClientHeartbeatMessage ) {
logger.info(message);
}
return null;
}
static Logger logger;
static   {
logger = Logger.getLogger(HeartbeatAdapter.class);
}
}
Testing the Client Heartbeat
The next step is to test a simple case where the client sends a dummy heartbeat to the
server. The ultimate goal is for the client heartbeat to carry the delivery confirmations
so that the server can resend the undelivered messages until they either get delivered
or time out.
Figure 5-1 highlights all classes that are involved in sending the client heartbeat. Notice
two projects: com.farata.rtmp.components, the Flex library project, and
220 | | Chapter 5: Customizing the Messaging Layer of LCDS or BlazeDS
JPEG to PDF Converter | Convert JPEG to PDF, Convert PDF to JPEG
Features and Benefits. Powerful image converter to convert images of JPG Support a batch conversion of JPG to PDF with high speed; Get a compressed PDF file after
change from pdf to jpg on; .pdf to jpg
VB.NET PDF - Convert PDF with VB.NET WPF PDF Viewer
An advanced PDF converter tool, which supports to be integrated in .NET to image file formats with high quality, support converting PDF to PNG, JPG, BMP and
convert from pdf to jpg; convert pdf file to jpg file
com.farata.rtmp.demo, a combined Eclipse JEE Flex/Java/Dynamic Web Project. For
messaging, we are using RTMP messaging via LiveCycle Data Services.
Figure 5-1. Panorama of ClientHeartbeat classes
To test the client heartbeat, run the application TestClientHeartbeat.mxml (Exam-
ple 5-6) and click the Start Client Heartbeat button. Watch how the server log gets
populated with the log records made by the custom 
HeartbeatAdapter
(Figure 5-2).
Example 5-6. TestClientHeartbeat.mxml
<?xml version="1.0" encoding="utf-8"?>
<!--TestClientHeartbeat.mxml -->
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml"
xmlns:fx="http://www.faratasystems.com/2009/components"
layout="vertical" frameRate="10">
<fx:ClientHeartbeatProducer id="clientHeartbeat" />
Testing the Client Heartbeat t | | 221
JPG to GIF Converter | Convert JPEG to GIF, Convert GIF to JPG
Features and Benefits. High speed JPEG to GIF Converter, faster than other JPG Converters; Standalone software, so the user who is not online still can use
change pdf to jpg file; reader convert pdf to jpg
VB.NET Create PDF from images Library to convert Jpeg, png images
Support create PDF from multiple image formats in VB.NET, including Jpg, Png, Bmp, Gif, Tiff, Bitmap, .NET Graphics, and REImage. .NET converter control for
convert pdf to jpg c#; reader pdf to jpeg
<mx:Script><![CDATA[
import com.farata.messaging.messages.ClientHeartbeatMessage;
//Mention the class to ensure that it's linked into SWF
ClientHeartbeatMessage;
]]>
</mx:Script>
<mx:HBox>
<mx:Button label="Start Client Heartbeat"
<mx:Button label="Stop Client Heartbeat"
click="clientHeartbeat.stopHeartbeat()"/>
</mx:HBox>
</mx:Application>
Figure 5-2. ClientHeartbeat logged by the custom HeartbeatAdapter
Guaranteed Delivery of Server Messages
A server can send various types of messages. When a client receives them, we want the
client to be able to send back the heartbeat object with delivery confirmations for only
some of them, similar to a special treatment that letters with delivery confirmation get
in the post office.
Our special messages will be represented by the class 
ReliableServerMessage
; only these
types of messages will be acknowledged. Java and ActionScript versions of such a class
are shown in Examples 5-7 and 5-8.
Example 5-7. ReliableServerMessage.java
package com.farata.messaging.messages;
import flex.messaging.messages.AsyncMessage;
import flex.messaging.util.UUIDUtils;
222 | | Chapter 5: Customizing the Messaging Layer of LCDS or BlazeDS
public class ReliableServerMessage extends AsyncMessage {
public ReliableServerMessage(Object body) {
super();
this.body = body;
setMessageId(UUIDUtils.createUUID(false));
timestamp = System.currentTimeMillis();
}
}
Example 5-8. ReliableServerMessage.as
package com.farata.messaging.messages {
import mx.messaging.messages.AsyncMessage;
public class ReliableServerMessage extends AsyncMessage{
}
}
The easiest way to identify the server-side outgoing message is by assigning some unique
sequence number to its header. Just as a reminder, each 
AsyncMessage
object has a
message body and a message header and you are allowed to attach any key/value pairs
to its header:
message = new ReliableServerMessage("Server message #"  + number);
message.setHeader("seqNo", "" + number);
On the client side, we receive each message and store the delivery slip until the next
heartbeat is generated. For example, if client heartbeats are being sent to the server
every 500 milliseconds but the message can arrive at any random time, the delivery slip
will have to wait for the next “shuttle” (a.k.a. heartbeat) to the server.
By this time, you already know that a communication channel is represented by the
endpoint on the server side. The client side is represented by a channel—an Action-
Script class that implements a selected communication protocol. For example, here’s
the configuration of our 
RTMPChannel
in services-config.xml in LCDS:
<channel-definition id="my-rtmp"
class="mx.messaging.channels.RTMPChannel">
<endpoint url="rtmp://localhost:2039"
class="flex.messaging.endpoints.RTMPEndpoint"/>
<properties>
<idle-timeout-minutes>30</idle-timeout-minutes>
</properties>
</channel-definition>
In this example, the ActionScript class 
RTMPChannel
represents the client side of the
RTMP channel. But we’ll write a custom class as a channel with a special treatment of
instances of the 
ReliableServerMessage
type. When creating a custom channel, you
override its method 
receive()
, storing each received message in the 
received
array; on
the next timer event 
receive()
will grab all received but unacknowledged messages,
put them in a heartbeat instance, and send them back to the server. Any other messages
Guaranteed Delivery of Server Messages s | | 223
will just be passed through the channel to the client application without acknowledg-
ments. Figure 5-3 presents such a design, in which our custom channel goes by the
working name AcknowledgingChannel.
Figure 5-3. Client processing with AcknowledgingChannel
You can say that by adding custom behavior on the protocol level we are enriching the
messaging service, or, in other words, adding quality of service (QoS) information to
the messages.
Figure 5-4 illustrates the server-side part. Some Java producers generate both regular
and reliable messages that go through a custom 
QoSAdapter
. The regular messages just
go right through to the destination, but the reliable ones are first saved in the 
Map
of
unconfirmed messages and will stay there until the confirmation from the client arrives.
When the server receives the client heartbeat with the batch of delivery confirmations,
the 
QoSAdapter
loops through the unconfirmed 
Map
and removes the messages that were
included in the heartbeat. The messages that haven’t been acknowledged by the client
can be resent, say, in a three-second interval. In some business cases, you might want
to remove the messages that are sitting unconfirmed for more than 20 seconds or any
other preferred interval.
All ActionScript and Java classes that support this process are highlighted in Figure 5-5.
224 | | Chapter 5: Customizing the Messaging Layer of LCDS or BlazeDS
Building a Custom Acknowledging Channel
In this section, we’ll build a custom acknowledging channel for the RTMP protocol,
even though you can implement a similar class for AMF-based messaging. The princi-
ples of creating custom channels remain the same regardless of the selected protocol.
We’ll discuss the differences of the communication protocols in Chapter 6.
As stated earlier, you need to overload the 
receive()
method and, for each incoming
instance of 
ReliableServerMessage
, add the 
clientId
concatenated with the message
sequence number to the array called 
received
:
override public function receive(
msg:IMessage, ...rest:Array) : void {
if (msg is ReliableServerMessage) {
var seqNo : Number = Number(msg.headers["seqNo"]);
received.push( msg.clientId + "|"+ seqNo);
Figure 5-4. Processing acknowledged messages on the server
Building a Custom Acknowledging Channel l | | 225
}
super.receive( msg, rest);
}
Every time the new message arrives from the server, the method 
receive()
will be called
and a new reliable message will be added to the array 
received
. As a reminder, adding
seqNo
in the message header should be done in the Java code that sends the message.
You’ll see the use of the message property 
clientId
a little later, on the server’s
QoSAdapter
; it’s used to avoid collision between multiple clients, potentially confirming
the same range of message sequences.
Figure 5-5. Classes involved in the No Server Message Left Behind solution
The code of the client’s custom RTMP channel is presented in Example 5-9. Note the
method 
getConfirmations()
, which will be used to move digests of all recently received
226 | | Chapter 5: Customizing the Messaging Layer of LCDS or BlazeDS
Documents you may be interested
Documents you may be interested