/// <summary>
/// Asynchronous callback that processes changes from Active Directory.
/// </summary>
/// <param name="asyncResult">Result of permanens search</param>
private void RunAsyncSearch(IAsyncResult asyncResult)
{
var results = new List <SearchResultEntry>();
// Get changes
if (!asyncResult.IsCompleted)
{
PartialResultsCollection partialResults = null;
try
{
partialResults = Connection.GetPartialResults(asyncResult);
}
catch (Exception e)
{
LogError("Retrieving partial results from Active Directory asynchronous search failed.", e);
}
if (partialResults != null)
{
// Add only users and groups
results.AddRange(partialResults.OfType <SearchResultEntry>().Where(p => LdapHelper.IsUser(p, PersonObjectCategory) || LdapHelper.IsGroup(p, GroupObjectCategory)));
}
}
else
{
LogMessage("The change notification control unexpectedly ended the search.");
mSearches.Remove(asyncResult);
StartIncrementalSynchronization();
}
// Send changes to CMS
Dispatcher.AddToQueue(results);
}
static void NotificationSearchCallback(IAsyncResult asyncRes)
{
asyncCallbackFinished = false;
Console.WriteLine("AsyncCallback invoked.");
Console.WriteLine("IAsyncResult.IsCompleted:" + asyncRes.IsCompleted);
Console.WriteLine("Retrieving partial results.");
PartialResultsCollection partialResults =
ldapConnection.GetPartialResults(asyncRes);
int count = 0;
foreach (object obj in partialResults)
{
count++;
if (obj is SearchResultEntry)
{
SearchResultEntry entry = (SearchResultEntry)obj;
Console.WriteLine(entry.DistinguishedName +
": Description:" + entry.Attributes["description"][0]);
}
else if (obj is SearchResultReference)
{
SearchResultReference reference = (SearchResultReference)obj;
Console.WriteLine("SearchResultReference:");
foreach (Uri uri in reference.Reference)
{
Console.WriteLine(uri);
}
}
}
asyncCallbackFinished = true;
}
private void Notify(IAsyncResult result)
{
PartialResultsCollection prc = _connection.GetPartialResults(result);
foreach (SearchResultEntry entry in prc)
{
OnObjectChanged(new ObjectChangedEventArgs(entry));
}
}
private void Notify(IAsyncResult result)
{
//since our search is long running, we don't want to use EndSendRequest
PartialResultsCollection prc = _connection.GetPartialResults(result);
foreach (SearchResultEntry entry in prc)
{
OnObjectChanged(new ObjectChangedEventArgs(entry));
}
}
private void InternalCallback(IAsyncResult result)
{
this.mutex.WaitOne();
Console.WriteLine(
"Callback on thread #{0}",
Thread.CurrentThread.ManagedThreadId
);
if (!result.IsCompleted)
{
PartialResultsCollection prc =
this.connect.GetPartialResults(result);
for (int i = 0; i < prc.Count; i++)
{
SearchResultEntry entry = prc[i]
as SearchResultEntry;
if (entry != null)
{
Console.WriteLine(
"Partial Result: {0}",
entry.DistinguishedName
);
}
}
}
else
{
SearchResponse response =
this.connect.EndSendRequest(result)
as SearchResponse;
foreach (SearchResultEntry entry
in response.Entries)
{
Console.WriteLine(entry.DistinguishedName);
}
}
this.mutex.ReleaseMutex();
}
private static void RunAsyncSearch(IAsyncResult asyncResult)
{
ASyncOperationState state = (ASyncOperationState)asyncResult.AsyncState;
try
{
if (!asyncResult.IsCompleted)
{
PartialResultsCollection partialResult = null;
partialResult = state.Connection.GetPartialResults(asyncResult);
if (partialResult != null)
{
for (int i = 0; i < partialResult.Count; i++)
{
if (partialResult[i] is SearchResultEntry)
{
Assert.True(((SearchResultEntry)partialResult[i]).DistinguishedName.Contains("Group9"));
}
}
}
}
else
{
SearchResponse response = (SearchResponse)state.Connection.EndSendRequest(asyncResult);
if (response != null)
{
foreach (SearchResultEntry entry in response.Entries)
{
Assert.True(entry.DistinguishedName.Contains("Group9"));
}
}
}
}
catch (Exception e)
{
state.Exception = e;
}
}
private void PagedAsyncQueryCallBackPartial(IAsyncResult Result)
{
PartialResultsCollection pResults = null;
SearchResultEntry[] temp = new SearchResultEntry[0];
if (!Result.IsCompleted)
{
pResults = base.Connection.GetPartialResults(Result);
if (pResults != null)
{
temp = new SearchResultEntry[pResults.Count];
pResults.CopyTo(temp, 0);
}
}
else
{
SearchResponse sresponse = null;
try
{
sresponse = (SearchResponse)base.AsyncConnection.EndSendRequest(Result);
}
catch (DirectoryOperationException direx)
{
if (direx.Response != null)
{
if (direx.Response.ResultCode == ResultCode.SizeLimitExceeded)
{
if (ForestBase.CurrentRequestExtender.QueryInfo.AutoPage)
{
GlobalEventHandler.RaiseErrorOccured(String.Format("Non-PagedQuery: {0} - switched to PagedQuery", direx.Response.ResultCode.ToString()));
ForestBase.CurrentRequestExtender.AddMessage(String.Format("Non-PagedQuery: {0} - switched to PagedQuery", direx.Response.ResultCode.ToString()));
ForestBase.CurrentRequestExtender.PageCookie(((SearchResponse)direx.Response).Entries.Count);
ForestBase.CurrentRequestExtender.MoreData = true;
PagedAsyncQuery();
}
}
}
}
catch (Exception ex)
{ string x = ex.Message; }
temp = new SearchResultEntry[sresponse.Entries.Count];
sresponse.Entries.CopyTo(temp, 0);
if (ForestBase.CurrentRequestExtender.RetreiveStatistics)
{
DirectoryControl dcStats = GetControl(sresponse.Controls, SearchRequestExtender.STATISTCS_CONTROL_OID);
if (dcStats != null)
{
ForestBase.CurrentRequestExtender.Statistics.Add(new StatsData(dcStats.GetValue()));
}
else
{
GlobalEventHandler.RaiseErrorOccured("WARNING: No Query Statistics data returned");
}
}
DirectoryControl pageRespControl = GetControl(sresponse.Controls, ForestBase.CurrentRequestExtender.PageControl.Type);
ForestBase.CurrentRequestExtender.UpdatePagingCookie(pageRespControl, sresponse.Entries.Count);
base.AsyncCalls--;
base.ParallelRuns--;
}
GlobalEventHandler.RaiseAsyncPartialResult(temp.ToList(), !ForestBase.CurrentRequestExtender.MoreData);
if (!CancelToken)
{
if (ForestBase.CurrentRequestExtender.MoreData)
{
PagedAsyncQuery();
}
else if (base.ParallelRuns < 1)
{
GlobalEventHandler.RaiseParallelQueriesCompleted();
}
}
else
{
GlobalEventHandler.RaiseParallelQueriesCompleted();
}
}
private void Notify(IAsyncResult result)
{
lock (this.lockObject)
{
try
{
if (this.stopped)
{
this.connection?.EndSendRequest(result);
return;
}
PartialResultsCollection resultsCollection = this.connection?.GetPartialResults(result);
if (resultsCollection == null)
{
this.Trace("Results collection was empty");
return;
}
if (DateTime.Now < this.nextTriggerAfter)
{
//this.Trace("Discarding change because next trigger time has not been reached");
return;
}
DateTime lastLogonOldestDate = DateTime.UtcNow.Subtract(this.LastLogonTimestampOffset);
foreach (SearchResultEntry r in resultsCollection.OfType <SearchResultEntry>())
{
if (r.Attributes == null || !r.Attributes.Contains(ActiveDirectoryChangeTrigger.ObjectClassAttribute))
{
this.Trace($"Skipping entry {r.DistinguishedName} because the object class list was empty");
continue;
}
IList <string> objectClasses = r.Attributes[ActiveDirectoryChangeTrigger.ObjectClassAttribute].GetValues(typeof(string)).OfType <string>().ToList();
if (!this.ObjectClasses.Intersect(objectClasses, StringComparer.OrdinalIgnoreCase).Any())
{
continue;
}
if (objectClasses.Contains("computer", StringComparer.OrdinalIgnoreCase) && !this.ObjectClasses.Contains("computer", StringComparer.OrdinalIgnoreCase))
{
continue;
}
bool dateTooSoon = false;
foreach (string timestampAttribute in ActiveDirectoryChangeTrigger.TimeStampAttributesToIgnore)
{
if (r.Attributes.Contains(timestampAttribute))
{
string ts = r.Attributes[timestampAttribute][0] as string;
DateTime date1 = DateTime.FromFileTimeUtc(Convert.ToInt64(ts));
if (date1 > lastLogonOldestDate)
{
dateTooSoon = true;
break;
}
}
}
if (dateTooSoon)
{
continue;
}
this.Log($"Change detected on {r.DistinguishedName}");
this.Fire();
}
}
catch (LdapException ex)
{
if (ex.ErrorCode == 85)
{
this.SetupListener();
}
else
{
this.LogError("The AD change listener encountered an unexpected error", ex);
if (MessageSender.CanSendMail())
{
string messageContent = MessageBuilder.GetMessageBody(this.ManagementAgentName, this.Type, this.Description, DateTime.Now, false, ex);
MessageSender.SendMessage($"{this.ManagementAgentName}: {this.Type} trigger error", messageContent);
Thread.Sleep(1000);
}
}
}
catch (Exception ex)
{
this.LogError("The AD change listener encountered an unexpected error", ex);
if (MessageSender.CanSendMail())
{
string messageContent = MessageBuilder.GetMessageBody(this.ManagementAgentName, this.Type, this.Description, DateTime.Now, false, ex);
MessageSender.SendMessage($"{this.ManagementAgentName}: {this.Type} trigger error", messageContent);
Thread.Sleep(1000);
}
}
}
}
