/// <summary>
/// Callback that is called when a Simias event is occurs.
/// </summary>
/// <param name="args">A SimiasEventArgs structure that contains event information.</param>
private void OnNotifyEvent(SimiasEventArgs args)
{
try
{
if (enabled)
{
NotifyEventArgs nArgs = args as NotifyEventArgs;
if ((nArgs != null) && (NotifyEvent != null))
{
Delegate[] cbList = NotifyEvent.GetInvocationList();
foreach (NotifyEventHandler cb in cbList)
{
try
{
cb(nArgs);
}
catch (Exception ex)
{
logger.Debug(ex, "Delegate {0}.{1} failed", cb.Target, cb.Method);
NotifyEvent -= cb;
}
}
}
}
}
catch (Exception ex)
{
new SimiasException(args.ToString(), ex);
}
}
/// <summary>
/// Callback for the event Need credentials
/// </summary>
/// <param name="args">Simias event</param>
private void OnNeedCredentials(SimiasEventArgs args)
{
try
{
if (enabled)
{
NeedCredentialsEventArgs cArgs = args as NeedCredentialsEventArgs;
if (cArgs != null)
{
if (NeedCredentials != null)
{
Delegate[] cbList = NeedCredentials.GetInvocationList();
foreach (NeedCredentialsEventHandler cb in cbList)
{
try
{
cb(cArgs);
}
catch
{
NeedCredentials -= cb;
}
}
}
}
}
}
catch (Exception ex)
{
new SimiasException(args.ToString(), ex);
}
}
/// <summary>
/// Called to raise an event.
/// </summary>
/// <param name="args">The arguments for the event.</param>
public void RaiseEvent(SimiasEventArgs args)
{
lock (eventQueue)
{
eventQueue.Enqueue(args);
haveEvents.Set();
}
}
/// <summary>
/// Call back method which is called when sync event occurs
/// </summary>
/// <param name="args">Simias event details</param>
private void OnSyncEvent(SimiasEventArgs args)
{
try
{
if (enabled)
{
CollectionSyncEventArgs cArgs = args as CollectionSyncEventArgs;
if (cArgs != null)
{
if (CollectionSync != null)
{
Delegate[] cbList = CollectionSync.GetInvocationList();
foreach (CollectionSyncEventHandler cb in cbList)
{
try
{
cb(cArgs);
}
catch (Exception ex)
{
logger.Debug(ex, "Delegate {0}.{1} failed", cb.Target, cb.Method);
CollectionSync -= cb;
}
}
}
}
else
{
FileSyncEventArgs fArgs = args as FileSyncEventArgs;
if (fArgs != null)
{
if (FileSync != null)
{
Delegate[] cbList = FileSync.GetInvocationList();
foreach (FileSyncEventHandler cb in cbList)
{
try
{
cb(fArgs);
}
catch (Exception ex)
{
logger.Debug(ex, "Delegate {0}.{1} failed", cb.Target, cb.Method);
FileSync -= cb;
}
}
}
}
}
}
}
catch (Exception ex)
{
new SimiasException(args.ToString(), ex);
}
}
/// <summary>
/// Called to publish a collection event.
/// </summary>
/// <param name="args">The arguments describing the event.</param>
public void RaiseEvent(SimiasEventArgs args)
{
try
{
broker.RaiseEvent(args);
}
catch
{
logger.Debug("Failed to Raise Event {0}", args.ToString());
}
}
/// <summary>
/// Thread that waits for the events and process them
/// </summary>
void EventQueueThread()
{
try
{
// Loop forever waiting for events to deliver.
while (true)
{
haveEvents.WaitOne();
while (true)
{
// We have at least one event loop until the queue is empty.
SimiasEventArgs args = null;
lock (eventQueue)
{
if (eventQueue.Count > 0)
{
args = (SimiasEventArgs)eventQueue.Dequeue();
}
else
{
break;
}
}
if (SimiasEvent != null)
{
Delegate[] cbList = SimiasEvent.GetInvocationList();
foreach (SimiasEventHandler cb in cbList)
{
try
{
cb(args);
/*
* cb.BeginInvoke(
* args,
* new AsyncCallback(EventRaisedCallback),
* null);
*/
}
catch (Exception ex)
{
logger.Debug(ex, "Delegate {0}.{1} failed", cb.Target, cb.Method);
}
}
}
}
}
}
catch {}
}
/// <summary>
/// Delegate for handling simias events
/// </summary>
/// <param name="args"></param>
void callDelegate(SimiasEventArgs args)
{
if (SimiasEvent != null)
{
Delegate[] cbList = SimiasEvent.GetInvocationList();
foreach (SimiasEventHandler cb in cbList)
{
try
{
cb(args);
}
catch (Exception ex)
{
logger.Debug(ex, "Delegate {0}.{1} failed", cb.Target, cb.Method);
}
}
}
}
private void SimiasEventHandler(SimiasEventArgs args)
{
try
{
lock (SimiasEventQueue)
{
SimiasEventQueue.Enqueue(args);
}
SEEvent.Set();
}
catch (Exception e)
{
if (printErrors)
{
Debug.PrintLine("Exception in SimiasEventHandler(): " + e.Message);
Debug.PrintLine(e.StackTrace);
}
}
}
/// <summary>
/// Callback for handling simias event received
/// </summary>
/// <param name="args">Simias even details</param>
private void OnSimiasEvent(SimiasEventArgs args)
{
try
{
string typeString = args.GetType().ToString();
switch (typeString)
{
case "Simias.Service.ShutdownEventArgs":
if (Shutdown != null)
{
Shutdown((ShutdownEventArgs)args);
}
break;
}
}
catch (Exception ex)
{
new SimiasException(args.ToString(), ex);
}
}
private void SimiasEventNotifyHandler(SimiasEventArgs args)
{
try
{
NotifyEventArgs notifyEventArgs = args as NotifyEventArgs;
lock (NotifyEventQueue)
{
NotifyEventQueue.Enqueue(notifyEventArgs);
GenericEventFired.WakeupMain();
}
}
catch (Exception e)
{
if (printErrors)
{
Debug.PrintLine("Exception in SimiasEventNotifyHandler(): " + e.Message);
Debug.PrintLine(e.StackTrace);
}
}
}
private void SimiasEventSyncFileHandler(SimiasEventArgs args)
{
try
{
FileSyncEventArgs fileSyncArgs = args as FileSyncEventArgs;
lock (FileEventQueue)
{
FileEventQueue.Enqueue(fileSyncArgs);
FileEventFired.WakeupMain();
}
}
catch (Exception e)
{
if (printErrors)
{
Debug.PrintLine("Exception in SimiasEventSyncFileHandler(): " + e.Message);
Debug.PrintLine(e.StackTrace);
}
}
}
private void fileSyncHandler(SimiasEventArgs args)
{
try
{
FileSyncEventArgs syncEventArgs = args as FileSyncEventArgs;
if (syncEventArgs.CollectionID.Equals(currentiFolder.ID))
{
BeginInvoke(fileSyncDelegate, new object[] {syncEventArgs});
}
}
catch {}
}
private void SimiasEventSyncFileHandler(SimiasEventArgs args)
{
try
{
FileSyncEventArgs fileSyncArgs = args as FileSyncEventArgs;
lock(FileEventQueue)
{
FileEventQueue.Enqueue(fileSyncArgs);
FileEventFired.WakeupMain();
}
}
catch(Exception e)
{
if (printErrors)
{
Debug.PrintLine("Exception in SimiasEventSyncFileHandler(): " + e.Message);
Debug.PrintLine(e.StackTrace);
}
}
}
private void SimiasEventSyncCollectionHandler(SimiasEventArgs args)
{
try
{
if (args == null)
{
Debug.PrintLine("SimiasEventSyncCollectionHandler received a null SimiasEventArgs");
return;
}
CollectionSyncEventArgs syncEventArgs =
args as CollectionSyncEventArgs;
if (syncEventArgs == null || syncEventArgs.Name == null || syncEventArgs.ID == null)
{
Debug.PrintLine("SimiasEventSyncCollectionHandler() Name, ID, Action, or Connected is null");
return;
}
if(ifdata.IsiFolder(syncEventArgs.ID))
{
iFolderHolder ifHolder =
ifdata.GetiFolder(syncEventArgs.ID);
if (ifHolder != null)
{
switch (syncEventArgs.Action)
{
case Simias.Client.Event.Action.StartLocalSync:
ifHolder.State = iFolderState.SynchronizingLocal;
break;
case Simias.Client.Event.Action.StartSync:
ifHolder.State = iFolderState.Synchronizing;
break;
case Simias.Client.Event.Action.StopSync:
try
{
SyncSize syncSize = ifws.CalculateSyncSize(syncEventArgs.ID);
ifHolder.ObjectsToSync = syncSize.SyncNodeCount;
}
catch
{}
if (ifHolder.ObjectsToSync > 0)
ifHolder.State = iFolderState.Normal;
else
{
if (syncEventArgs.Connected || ifHolder.iFolder.Role == "Master")
ifHolder.State = iFolderState.Normal;
else
ifHolder.State = iFolderState.Disconnected;
}
break;
}
if( (ifHolder.iFolder.UnManagedPath == null) ||
(ifHolder.iFolder.UnManagedPath.Length == 0) )
{
ifHolder = ifdata.ReadiFolder(syncEventArgs.ID);
if (ifHolder != null)
{
lock(NodeEventQueue)
{
NodeEventQueue.Enqueue(new SimiasEvent(
ifHolder.iFolder.ID, null,
null, SimiasEventType.ChangediFolder));
SimiasEventFired.WakeupMain();
}
}
}
}
}
lock(SyncEventQueue)
{
SyncEventQueue.Enqueue(syncEventArgs);
SyncEventFired.WakeupMain();
}
}
catch(Exception e)
{
if (printErrors)
{
Debug.PrintLine("Exception in SimiasEventSyncCollectionHandler(): " + e.Message);
Debug.PrintLine(e.StackTrace);
}
}
}
private void SimiasEventNotifyHandler(SimiasEventArgs args)
{
try
{
NotifyEventArgs notifyEventArgs = args as NotifyEventArgs;
lock(NotifyEventQueue)
{
NotifyEventQueue.Enqueue(notifyEventArgs);
GenericEventFired.WakeupMain();
}
}
catch(Exception e)
{
if (printErrors)
{
Debug.PrintLine("Exception in SimiasEventNotifyHandler(): " + e.Message);
Debug.PrintLine(e.StackTrace);
}
}
}
private void SimiasEventHandler(SimiasEventArgs args)
{
try
{
lock(SimiasEventQueue)
{
SimiasEventQueue.Enqueue(args);
}
SEEvent.Set();
}
catch(Exception e)
{
if (printErrors)
{
Debug.PrintLine("Exception in SimiasEventHandler(): " + e.Message);
Debug.PrintLine(e.StackTrace);
}
}
}
private void trayApp_nodeEventHandler(SimiasEventArgs args)
{
try
{
NodeEventArgs eventArgs = args as NodeEventArgs;
lock (eventQueue.SyncRoot)
{
eventQueue.Enqueue(eventArgs);
workEvent.Set();
}
}
catch {}
}
private void SimiasEventSyncCollectionHandler(SimiasEventArgs args)
{
try
{
if (args == null)
{
Debug.PrintLine("SimiasEventSyncCollectionHandler received a null SimiasEventArgs");
return;
}
CollectionSyncEventArgs syncEventArgs =
args as CollectionSyncEventArgs;
if (syncEventArgs == null || syncEventArgs.Name == null || syncEventArgs.ID == null)
{
Debug.PrintLine("SimiasEventSyncCollectionHandler() Name, ID, Action, or Connected is null");
return; // Prevent a null object
}
if (ifdata.IsiFolder(syncEventArgs.ID))
{
iFolderHolder ifHolder =
ifdata.GetiFolder(syncEventArgs.ID);
if (ifHolder != null)
{
switch (syncEventArgs.Action)
{
case Simias.Client.Event.Action.StartLocalSync:
ifHolder.State = iFolderState.SynchronizingLocal;
break;
case Simias.Client.Event.Action.StartSync:
ifHolder.State = iFolderState.Synchronizing;
break;
case Simias.Client.Event.Action.StopSync:
try
{
SyncSize syncSize = ifws.CalculateSyncSize(syncEventArgs.ID);
ifHolder.ObjectsToSync = syncSize.SyncNodeCount;
}
catch
{}
if (ifHolder.ObjectsToSync > 0)
{
ifHolder.State = iFolderState.Normal;
}
else
{
if (syncEventArgs.Connected || ifHolder.iFolder.Role == "Master")
{
ifHolder.State = iFolderState.Normal;
}
else
{
ifHolder.State = iFolderState.Disconnected;
}
}
break;
}
if ((ifHolder.iFolder.UnManagedPath == null) ||
(ifHolder.iFolder.UnManagedPath.Length == 0))
{
// Because the iFolder has no path
// re-read the iFolder and fire a changed event
ifHolder = ifdata.ReadiFolder(syncEventArgs.ID);
if (ifHolder != null)
{
lock (NodeEventQueue)
{
NodeEventQueue.Enqueue(new SimiasEvent(
ifHolder.iFolder.ID, null,
null, SimiasEventType.ChangediFolder));
SimiasEventFired.WakeupMain();
}
}
}
}
}
// pass the sync event on to the client
lock (SyncEventQueue)
{
SyncEventQueue.Enqueue(syncEventArgs);
SyncEventFired.WakeupMain();
}
}
catch (Exception e)
{
if (printErrors)
{
Debug.PrintLine("Exception in SimiasEventSyncCollectionHandler(): " + e.Message);
Debug.PrintLine(e.StackTrace);
}
}
}
private void trayApp_collectionSyncHandler(SimiasEventArgs args)
{
try
{
CollectionSyncEventArgs syncEventArgs = args as CollectionSyncEventArgs;
BeginInvoke(syncCollectionDelegate, new object[] {syncEventArgs});
}
catch {}
}
private void SimiasEventSyncFileHandler(SimiasEventArgs args)
{
FileSyncEventArgs fileSyncArgs = args as FileSyncEventArgs;
lock(FileEventQueue)
{
FileEventQueue.Enqueue(fileSyncArgs);
FileEventFired.WakeupMain();
}
}
private void SimiasEventSyncCollectionHandler(SimiasEventArgs args)
{
CollectionSyncEventArgs syncEventArgs =
args as CollectionSyncEventArgs;
if(ifdata.IsiFolder(syncEventArgs.ID))
{
iFolderHolder ifHolder =
ifdata.GetiFolder(syncEventArgs.ID);
switch (syncEventArgs.Action)
{
case Simias.Client.Event.Action.StartLocalSync:
ifHolder.State = iFolderState.SynchronizingLocal;
break;
case Simias.Client.Event.Action.StartSync:
ifHolder.State = iFolderState.Synchronizing;
break;
case Simias.Client.Event.Action.StopSync:
try
{
SyncSize syncSize = ifws.CalculateSyncSize(syncEventArgs.ID);
ifHolder.ObjectsToSync = syncSize.SyncNodeCount;
}
catch
{}
if (ifHolder.ObjectsToSync > 0)
ifHolder.State = iFolderState.Normal;
else
{
if (syncEventArgs.Connected)
ifHolder.State = iFolderState.Normal;
else
ifHolder.State = iFolderState.Disconnected;
}
break;
}
if( (ifHolder.iFolder.UnManagedPath == null) ||
(ifHolder.iFolder.UnManagedPath.Length == 0) )
{
ifHolder = ifdata.ReadiFolder(syncEventArgs.ID);
lock(NodeEventQueue)
{
NodeEventQueue.Enqueue(new SimiasEvent(
ifHolder.iFolder.ID, null,
null, SimiasEventType.ChangediFolder));
SimiasEventFired.WakeupMain();
}
}
}
lock(SyncEventQueue)
{
SyncEventQueue.Enqueue(syncEventArgs);
SyncEventFired.WakeupMain();
}
}
private void SimiasEventNotifyHandler(SimiasEventArgs args)
{
NotifyEventArgs notifyEventArgs = args as NotifyEventArgs;
lock(NotifyEventQueue)
{
NotifyEventQueue.Enqueue(notifyEventArgs);
GenericEventFired.WakeupMain();
}
}
private void SimiasEventHandler(SimiasEventArgs args)
{
lock(SimiasEventQueue)
{
SimiasEventQueue.Enqueue(args);
}
SEEvent.Set();
}
private void trayApp_fileSyncHandler(SimiasEventArgs args)
{
try
{
FileSyncEventArgs syncEventArgs = args as FileSyncEventArgs;
BeginInvoke(syncFileDelegate, new object[] {syncEventArgs});
}
catch {}
}
/// <summary>
/// Called when an event has been triggered.
/// </summary>
/// <param name="args">Arguments for the event.</param>
public void OnSimiasEvent(SimiasEventArgs args)
{
callDelegate(args);
}
private void trayApp_notifyMessageHandler(SimiasEventArgs args)
{
try
{
NotifyEventArgs notifyEventArgs = args as NotifyEventArgs;
BeginInvoke(notifyMessageDelegate, new object[] {notifyEventArgs});
}
catch {}
}
/// <summary>
/// When Collection even is generated, this method is called
/// </summary>
/// <param name="args">Simias event details</param>
private void OnCollectionEvent(SimiasEventArgs args)
{
try
{
NodeEventArgs nodeArgs = args as NodeEventArgs;
if (nodeArgs != null)
{
if (applyNodeFilter(nodeArgs))
{
EventType changeType = (EventType)Enum.Parse(typeof(EventType), (string)nodeArgs.EventData, false);
switch (changeType)
{
case EventType.NodeChanged:
if (NodeChanged != null)
{
Delegate[] cbList = NodeChanged.GetInvocationList();
foreach (NodeEventHandler cb in cbList)
{
try
{
cb(nodeArgs);
}
catch (Exception ex)
{
logger.Debug(ex, "Delegate {0}.{1} failed", cb.Target, cb.Method);
NodeChanged -= cb;
}
}
}
break;
case EventType.NodeCreated:
if (NodeCreated != null)
{
Delegate[] cbList = NodeCreated.GetInvocationList();
foreach (NodeEventHandler cb in cbList)
{
try
{
cb(nodeArgs);
}
catch (Exception ex)
{
logger.Debug(ex, "Delegate {0}.{1} failed", cb.Target, cb.Method);
NodeCreated -= cb;
}
}
}
break;
case EventType.NodeDeleted:
if (NodeDeleted != null)
{
Delegate[] cbList = NodeDeleted.GetInvocationList();
foreach (NodeEventHandler cb in cbList)
{
try
{
cb(nodeArgs);
}
catch (Exception ex)
{
logger.Debug(ex, "Delegate {0}.{1} failed", cb.Target, cb.Method);
NodeDeleted -= cb;
}
}
}
break;
case EventType.NoAccess:
if (NoAccess != null)
{
Delegate[] cbList = NoAccess.GetInvocationList();
foreach (NodeEventHandler cb in cbList)
{
try
{
cb(nodeArgs);
}
catch (Exception ex)
{
logger.Debug(ex, "Delegate {0}.{1} failed", cb.Target, cb.Method);
NodeDeleted -= cb;
}
}
}
break;
}
}
}
}
catch (Exception ex)
{
new SimiasException(args.ToString(), ex);
}
}
