/*
* The MIT License
* Copyright (c) 2012 Microsoft Corporation
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package microsoft.exchange.webservices.data.notification;
import microsoft.exchange.webservices.data.core.EwsUtilities;
import microsoft.exchange.webservices.data.core.ExchangeService;
import microsoft.exchange.webservices.data.core.exception.misc.ArgumentNullException;
import microsoft.exchange.webservices.data.core.request.GetStreamingEventsRequest;
import microsoft.exchange.webservices.data.core.request.HangingRequestDisconnectEventArgs;
import microsoft.exchange.webservices.data.core.request.HangingServiceRequestBase;
import microsoft.exchange.webservices.data.core.response.GetStreamingEventsResponse;
import microsoft.exchange.webservices.data.core.enumeration.misc.ExchangeVersion;
import microsoft.exchange.webservices.data.core.enumeration.misc.error.ServiceError;
import microsoft.exchange.webservices.data.core.enumeration.service.ServiceResult;
import microsoft.exchange.webservices.data.core.exception.misc.ArgumentException;
import microsoft.exchange.webservices.data.core.exception.misc.ArgumentOutOfRangeException;
import microsoft.exchange.webservices.data.core.exception.service.local.ServiceLocalException;
import microsoft.exchange.webservices.data.core.exception.service.remote.ServiceResponseException;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import java.io.Closeable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* Represents a connection to an ongoing stream of events.
*/
public final class StreamingSubscriptionConnection implements Closeable,
HangingServiceRequestBase.IHandleResponseObject,
HangingServiceRequestBase.IHangingRequestDisconnectHandler {
private static final Log LOG = LogFactory.getLog(StreamingSubscriptionConnection.class);
/**
* Mapping of streaming id to subscriptions currently on the connection.
*/
private Map<String, StreamingSubscription> subscriptions;
/**
* connection lifetime, in minutes
*/
private int connectionTimeout;
/**
* ExchangeService instance used to make the EWS call.
*/
private ExchangeService session;
/**
* Value indicating whether the class is disposed.
*/
private boolean isDisposed;
/**
* Currently used instance of a GetStreamingEventsRequest connected to EWS.
*/
private GetStreamingEventsRequest currentHangingRequest;
public interface INotificationEventDelegate {
/**
* Represents a delegate that is invoked when notification are received
* from the server
*
* @param sender The StreamingSubscriptionConnection instance that received
* the events.
* @param args The event data.
*/
void notificationEventDelegate(Object sender, NotificationEventArgs args);
}
/**
* Notification events Occurs when notification are received from the
* server.
*/
private List<INotificationEventDelegate> onNotificationEvent = new ArrayList<INotificationEventDelegate>();
/**
* Set event to happen when property Notify.
*
* @param notificationEvent notification event
*/
public void addOnNotificationEvent(
INotificationEventDelegate notificationEvent) {
onNotificationEvent.add(notificationEvent);
}
/**
* Remove the event from happening when property Notify.
*
* @param notificationEvent notification event
*/
public void removeNotificationEvent(
INotificationEventDelegate notificationEvent) {
onNotificationEvent.remove(notificationEvent);
}
/**
* Clears notification events list.
*/
public void clearNotificationEvent() {
onNotificationEvent.clear();
}
public interface ISubscriptionErrorDelegate {
/**
* Represents a delegate that is invoked when an error occurs within a
* streaming subscription connection.
*
* @param sender The StreamingSubscriptionConnection instance within which
* the error occurred.
* @param args The event data.
*/
void subscriptionErrorDelegate(Object sender,
SubscriptionErrorEventArgs args);
}
/**
* Subscription events Occur when a subscription encounters an error.
*/
private List<ISubscriptionErrorDelegate> onSubscriptionError = new ArrayList<ISubscriptionErrorDelegate>();
/**
* Set event to happen when property subscriptionError.
*
* @param subscriptionError subscription event
*/
public void addOnSubscriptionError(
ISubscriptionErrorDelegate subscriptionError) {
onSubscriptionError.add(subscriptionError);
}
/**
* Remove the event from happening when property subscription.
*
* @param subscriptionError subscription event
*/
public void removeSubscriptionError(
ISubscriptionErrorDelegate subscriptionError) {
onSubscriptionError.remove(subscriptionError);
}
/**
* Clears subscription events list.
*/
public void clearSubscriptionError() {
onSubscriptionError.clear();
}
/**
* Disconnect events Occurs when a streaming subscription connection is
* disconnected from the server.
*/
private List<ISubscriptionErrorDelegate> onDisconnect = new ArrayList<ISubscriptionErrorDelegate>();
/**
* Set event to happen when property disconnect.
*
* @param disconnect disconnect event
*/
public void addOnDisconnect(ISubscriptionErrorDelegate disconnect) {
onDisconnect.add(disconnect);
}
/**
* Remove the event from happening when property disconnect.
*
* @param disconnect disconnect event
*/
public void removeDisconnect(ISubscriptionErrorDelegate disconnect) {
onDisconnect.remove(disconnect);
}
/**
* Clears disconnect events list.
*/
public void clearDisconnect() {
onDisconnect.clear();
}
/**
* Initializes a new instance of the StreamingSubscriptionConnection class.
*
* @param service The ExchangeService instance this connection uses to connect
* to the server.
* @param lifetime The maximum time, in minutes, the connection will remain open.
* Lifetime must be between 1 and 30.
* @throws Exception
*/
public StreamingSubscriptionConnection(ExchangeService service, int lifetime)
throws Exception {
EwsUtilities.validateParam(service, "service");
EwsUtilities.validateClassVersion(service,
ExchangeVersion.Exchange2010_SP1, this.getClass().getName());
if (lifetime < 1 || lifetime > 30) {
throw new ArgumentOutOfRangeException("lifetime");
}
this.session = service;
this.subscriptions = new HashMap<String, StreamingSubscription>();
this.connectionTimeout = lifetime;
}
/**
* Initializes a new instance of the StreamingSubscriptionConnection class.
*
* @param service The ExchangeService instance this connection uses to connect
* to the server.
* @param subscriptions Iterable subcriptions
* @param lifetime The maximum time, in minutes, the connection will remain open.
* Lifetime must be between 1 and 30.
* @throws Exception
*/
public StreamingSubscriptionConnection(ExchangeService service,
Iterable<StreamingSubscription> subscriptions, int lifetime)
throws Exception {
this(service, lifetime);
EwsUtilities.validateParamCollection(subscriptions.iterator(), "subscriptions");
for (StreamingSubscription subscription : subscriptions) {
this.subscriptions.put(subscription.getId(), subscription);
}
}
/**
* Adds a subscription to this connection.
*
* @param subscription The subscription to add.
* @throws Exception Thrown when AddSubscription is called while connected.
*/
public void addSubscription(StreamingSubscription subscription)
throws Exception {
this.throwIfDisposed();
EwsUtilities.validateParam(subscription, "subscription");
this.validateConnectionState(false, "Subscriptions can't be added to an open connection.");
synchronized (this) {
if (this.subscriptions.containsKey(subscription.getId())) {
return;
}
this.subscriptions.put(subscription.getId(), subscription);
}
}
/**
* Removes the specified streaming subscription from the connection.
*
* @param subscription The subscription to remove.
* @throws Exception Thrown when RemoveSubscription is called while connected.
*/
public void removeSubscription(StreamingSubscription subscription)
throws Exception {
this.throwIfDisposed();
EwsUtilities.validateParam(subscription, "subscription");
this.validateConnectionState(false, "Subscriptions can't be removed from an open connection.");
synchronized (this) {
this.subscriptions.remove(subscription.getId());
}
}
/**
* Opens this connection so it starts receiving events from the server.This
* results in a long-standing call to EWS.
*
* @throws Exception
* @throws ServiceLocalException Thrown when Open is called while connected.
*/
public void open() throws ServiceLocalException, Exception {
synchronized (this) {
this.throwIfDisposed();
this.validateConnectionState(false, "The connection has already opened.");
if (this.subscriptions.size() == 0) {
throw new ServiceLocalException(
"You must add at least one subscription to this connection before it can be opened.");
}
this.currentHangingRequest = new GetStreamingEventsRequest(
this.session, this, this.subscriptions.keySet(),
this.connectionTimeout);
this.currentHangingRequest.addOnDisconnectEvent(this);
this.currentHangingRequest.internalExecute();
}
}
/**
* Called when the request is disconnected.
*
* @param sender The sender.
* @param args The Microsoft.Exchange.WebServices.Data.
* HangingRequestDisconnectEventArgs instance containing the
* event data.
*/
private void onRequestDisconnect(Object sender,
HangingRequestDisconnectEventArgs args) {
this.internalOnDisconnect(args.getException());
}
/**
* Closes this connection so it stops receiving events from the server.This
* terminates a long-standing call to EWS.
*/
public void close() {
synchronized (this) {
try {
this.throwIfDisposed();
this.validateConnectionState(true, "The connection is already closed.");
// Further down in the stack, this will result in a
// call to our OnRequestDisconnect event handler,
// doing the necessary cleanup.
this.currentHangingRequest.disconnect();
} catch (Exception e) {
LOG.error(e);
}
}
}
/**
* Internal helper method called when the request disconnects.
*
* @param ex The exception that caused the disconnection. May be null.
*/
private void internalOnDisconnect(Exception ex) {
if (!onDisconnect.isEmpty()) {
for (ISubscriptionErrorDelegate disconnect : onDisconnect) {
disconnect.subscriptionErrorDelegate(this,
new SubscriptionErrorEventArgs(null, ex));
}
}
this.currentHangingRequest = null;
}
/**
* Gets a value indicating whether this connection is opened
*
* @throws Exception
*/
public boolean getIsOpen() throws Exception {
this.throwIfDisposed();
if (this.currentHangingRequest == null) {
return false;
} else {
return this.currentHangingRequest.isConnected();
}
}
/**
* Validates the state of the connection.
*
* @param isConnectedExpected Value indicating whether we expect to be currently connected.
* @param errorMessage The error message.
* @throws Exception
*/
private void validateConnectionState(boolean isConnectedExpected,
String errorMessage) throws Exception {
if ((isConnectedExpected && !this.getIsOpen())
|| (!isConnectedExpected && this.getIsOpen())) {
throw new ServiceLocalException(errorMessage);
}
}
/**
* Handles the service response object.
*
* @param response The response.
* @throws ArgumentException
*/
private void handleServiceResponseObject(Object response)
throws ArgumentException {
GetStreamingEventsResponse gseResponse = (GetStreamingEventsResponse) response;
if (gseResponse == null) {
throw new ArgumentNullException("GetStreamingEventsResponse must not be null",
"GetStreamingEventsResponse");
} else {
if (gseResponse.getResult() == ServiceResult.Success
|| gseResponse.getResult() == ServiceResult.Warning) {
if (gseResponse.getResults().getNotifications().size() > 0) {
// We got notification; dole them out.
this.issueNotificationEvents(gseResponse);
} else {
// // This was just a heartbeat, nothing to do here.
}
} else if (gseResponse.getResult() == ServiceResult.Error) {
if (gseResponse.getErrorSubscriptionIds() == null
|| gseResponse.getErrorSubscriptionIds().size() == 0) {
// General error
this.issueGeneralFailure(gseResponse);
} else {
// subscription-specific errors
this.issueSubscriptionFailures(gseResponse);
}
}
}
}
/**
* Issues the subscription failures.
*
* @param gseResponse The GetStreamingEvents response.
*/
private void issueSubscriptionFailures(
GetStreamingEventsResponse gseResponse) {
ServiceResponseException exception = new ServiceResponseException(
gseResponse);
for (String id : gseResponse.getErrorSubscriptionIds()) {
StreamingSubscription subscription = null;
synchronized (this) {
// Client can do any good or bad things in the below event
// handler
if (this.subscriptions != null
&& this.subscriptions.containsKey(id)) {
subscription = this.subscriptions.get(id);
}
}
if (subscription != null) {
SubscriptionErrorEventArgs eventArgs = new SubscriptionErrorEventArgs(
subscription, exception);
if (!onSubscriptionError.isEmpty()) {
for (ISubscriptionErrorDelegate subError : onSubscriptionError) {
subError.subscriptionErrorDelegate(this, eventArgs);
}
}
}
if (gseResponse.getErrorCode() != ServiceError.ErrorMissedNotificationEvents) {
// Client can do any good or bad things in the above event
// handler
synchronized (this) {
if (this.subscriptions != null
&& this.subscriptions.containsKey(id)) {
// We are no longer servicing the subscription.
this.subscriptions.remove(id);
}
}
}
}
}
/**
* Issues the general failure.
*
* @param gseResponse The GetStreamingEvents response.
*/
private void issueGeneralFailure(GetStreamingEventsResponse gseResponse) {
SubscriptionErrorEventArgs eventArgs = new SubscriptionErrorEventArgs(
null, new ServiceResponseException(gseResponse));
if (!onSubscriptionError.isEmpty()) {
for (ISubscriptionErrorDelegate subError : onSubscriptionError) {
subError.subscriptionErrorDelegate(this, eventArgs);
}
}
}
/**
* Issues the notification events.
*
* @param gseResponse The GetStreamingEvents response.
*/
private void issueNotificationEvents(GetStreamingEventsResponse gseResponse) {
for (GetStreamingEventsResults.NotificationGroup events : gseResponse
.getResults().getNotifications()) {
StreamingSubscription subscription = null;
synchronized (this) {
// Client can do any good or bad things in the below event
// handler
if (this.subscriptions != null
&& this.subscriptions
.containsKey(events.subscriptionId)) {
subscription = this.subscriptions
.get(events.subscriptionId);
}
}
if (subscription != null) {
NotificationEventArgs eventArgs = new NotificationEventArgs(
subscription, events.events);
if (!onNotificationEvent.isEmpty()) {
for (INotificationEventDelegate notifyEvent : onNotificationEvent) {
notifyEvent.notificationEventDelegate(this, eventArgs);
}
}
}
}
}
/**
* Frees resources associated with this StreamingSubscriptionConnection.
*/
public void dispose() {
synchronized (this) {
if (!this.isDisposed) {
if (this.currentHangingRequest != null) {
this.currentHangingRequest = null;
}
this.subscriptions = null;
this.session = null;
this.isDisposed = true;
}
}
}
/**
* Throws if disposed.
*
* @throws Exception
*/
private void throwIfDisposed() throws Exception {
if (this.isDisposed) {
throw new Exception(this.getClass().getName());
}
}
@Override
public void handleResponseObject(Object response) throws ArgumentException {
this.handleServiceResponseObject(response);
}
@Override
public void hangingRequestDisconnectHandler(Object sender,
HangingRequestDisconnectEventArgs args) {
this.onRequestDisconnect(sender, args);
}
}