async Task ProcessQuantum(HandleItem handleItem)
{
var envelope = handleItem.Quantum;
var tcs = handleItem.HandlingTaskSource;
ResultMessage result = null;
try
{
Context.ExtensionsManager.BeforeQuantumHandle(envelope);
result = await HandleQuantumInternal(envelope, handleItem.Timestamp);
if (result.Status != ResultStatusCodes.Success)
{
throw new Exception("Failed to handle quantum.");
}
tcs.SetResult(result);
}
catch (Exception exc)
{
tcs.SetException(exc);
OnProcessException(handleItem, result, exc);
}
Context.ExtensionsManager.AfterQuantumHandle(result);
}
async Task ProcessQuantum(HandleItem handleItem)
{
var envelope = handleItem.Quantum;
var tcs = handleItem.HandlingTaskSource;
ResultMessage result = null;
try
{
Global.ExtensionsManager.BeforeQuantumHandle(envelope);
result = await HandleQuantum(envelope, handleItem.Timestamp);
if (result.Status != ResultStatusCodes.Success)
{
throw new Exception();
}
tcs.SetResult(result);
}
catch (Exception exc)
{
if (result == null)
{
result = envelope.CreateResult(exc);
}
Notifier.OnMessageProcessResult(result);
tcs.SetException(exc);
if (!Global.IsAlpha) //auditor should fail on quantum processing handling
{
throw;
}
}
Global.ExtensionsManager.AfterQuantumHandle(result);
}
private void menuHandle_Popup(object sender, EventArgs e)
{
protectedMenuItem.Checked = false;
inheritMenuItem.Checked = false;
if (listHandles.SelectedItems.Count == 0)
{
//menuHandle.DisableAll();
}
else if (listHandles.SelectedItems.Count == 1)
{
menuHandle.EnableAll();
HandleItem item = (HandleItem)listHandles.SelectedItems[0].Tag;
protectedMenuItem.Checked = (item.Handle.Flags & HandleFlags.ProtectFromClose) != 0;
inheritMenuItem.Checked = (item.Handle.Flags & HandleFlags.Inherit) != 0;
}
else
{
menuHandle.EnableAll();
propertiesHandleMenuItem.Enabled = false;
protectedMenuItem.Enabled = false;
inheritMenuItem.Enabled = false;
}
}
private void provider_DictionaryRemoved(HandleItem item)
{
this.BeginInvoke(new MethodInvoker(() =>
{
lock (_listLock)
listHandles.Items[item.Handle.Handle.ToString()].Remove();
}));
}
protected override void OnProcessException(HandleItem handleItem, ResultMessage result, Exception exc)
{
if (result == null)
{
result = handleItem.Quantum.CreateResult(exc);
}
Context.OnMessageProcessResult(result);
}
private void provider_DictionaryModified(HandleItem oldItem, HandleItem newItem)
{
this.BeginInvoke(new MethodInvoker(() =>
{
lock (_listLock)
{
((HighlightedListViewItem)this.listHandles.Items[newItem.Handle.Handle.ToString()]).NormalColor = this.GetHandleColor(newItem);
}
}));
}
/// <summary>
/// Handles the quantum and returns Task.
/// </summary>
/// <param name="envelope">Quantum to handle</param>
/// <param name="long">Quantum timestamp. We need it for quanta recovery, otherwise Alpha will have different hash.</param>
public virtual Task <ResultMessage> HandleAsync(MessageEnvelope envelope, long timestamp = 0)
{
if (QuantaThrottlingManager.Current.IsThrottlingEnabled && QuantaThrottlingManager.Current.MaxItemsPerSecond <= awaitedQuanta.Count)
{
throw new TooManyRequestsException("Server is too busy. Try again later.");
}
var newHandleItem = new HandleItem(envelope, timestamp);
awaitedQuanta.Add(newHandleItem);
return(newHandleItem.HandlingTaskSource.Task);
}
private void provider_DictionaryAdded(HandleItem item)
{
HighlightedListViewItem litem = new HighlightedListViewItem(_highlightingContext,
item.RunId > 0 && _runCount > 0);
litem.Name = item.Handle.Handle.ToString();
litem.Text = item.ObjectInfo.TypeName;
litem.SubItems.Add(new ListViewItem.ListViewSubItem(litem, item.ObjectInfo.BestName));
litem.SubItems.Add(new ListViewItem.ListViewSubItem(litem, "0x" + item.Handle.Handle.ToString("x")));
litem.Tag = item;
litem.NormalColor = this.GetHandleColor(item);
lock (_needsAdd)
_needsAdd.Add(litem);
}
private Color GetHandleColor(HandleItem item)
{
if (Settings.Instance.UseColorProtectedHandles &&
(item.Handle.Flags & HandleFlags.ProtectFromClose) != 0
)
{
return(Settings.Instance.ColorProtectedHandles);
}
if (Settings.Instance.UseColorInheritHandles &&
(item.Handle.Flags & HandleFlags.Inherit) != 0
)
{
return(Settings.Instance.ColorInheritHandles);
}
return(SystemColors.Window);
}
private Color GetHandleColor(HandleItem item)
{
if (Properties.Settings.Default.UseColorProtectedHandles &&
(item.Handle.Flags & HandleFlags.ProtectFromClose) != 0
)
{
return(Properties.Settings.Default.ColorProtectedHandles);
}
else if (Properties.Settings.Default.UseColorInheritHandles &&
(item.Handle.Flags & HandleFlags.Inherit) != 0
)
{
return(Properties.Settings.Default.ColorInheritHandles);
}
else
{
return(SystemColors.Window);
}
}
public static void Handle(IClientMessage clientMessage, HandleItem handleItem)
{
var messageType = clientMessage.GetMessageType();
if (messageType == EventMessageConst.EventItem)
{
IData item = null;
var itemIsNull = clientMessage.GetBoolean();
if (!itemIsNull)
{
item = clientMessage.GetData();
}
var uuid = clientMessage.GetStringUtf8();
var eventType = clientMessage.GetInt();
handleItem(item, uuid, eventType);
return;
}
Hazelcast.Logging.Logger.GetLogger(typeof(AbstractEventHandler))
.Warning("Unknown message type received on event handler :" + clientMessage.GetMessageType());
}
public static void Handle(IClientMessage clientMessage, HandleItem handleItem)
{
int messageType = clientMessage.GetMessageType();
if (messageType == EventMessageConst.EventItem)
{
IData item = null;
bool item_isNull = clientMessage.GetBoolean();
if (!item_isNull)
{
item = clientMessage.GetData();
}
string uuid = null;
uuid = clientMessage.GetStringUtf8();
int eventType;
eventType = clientMessage.GetInt();
handleItem(item, uuid, eventType);
return;
}
Hazelcast.Logging.Logger.GetLogger(typeof(AbstractEventHandler)).Warning("Unknown message type received on event handler :" + clientMessage.GetMessageType());
}
private void inheritMenuItem_Click(object sender, EventArgs e)
{
HandleItem item = (HandleItem)listHandles.SelectedItems[0].Tag;
HandleFlags flags = item.Handle.Flags;
if ((flags & HandleFlags.Inherit) != 0)
{
flags &= ~HandleFlags.Inherit;
}
else
{
flags |= HandleFlags.Inherit;
}
try
{
//using (var phandle = new ProcessHandle(_pid, Program.MinProcessQueryRights))
//KProcessHacker.Instance.SetHandleAttributes(phandle, new IntPtr(item.Handle.Handle), flags);
}
catch (Exception ex)
{
PhUtils.ShowException("Unable to set handle attributes", ex);
}
}
private Color GetHandleColor(HandleItem item)
{
if (Properties.Settings.Default.UseColorProtectedHandles &&
(item.Handle.Flags & HandleFlags.ProtectFromClose) != 0
)
return Properties.Settings.Default.ColorProtectedHandles;
else if (Properties.Settings.Default.UseColorInheritHandles &&
(item.Handle.Flags & HandleFlags.Inherit) != 0
)
return Properties.Settings.Default.ColorInheritHandles;
else
return SystemColors.Window;
}
private Color GetHandleColor(HandleItem item)
{
if (Settings.Instance.UseColorProtectedHandles &&
(item.Handle.Flags & HandleFlags.ProtectFromClose) != 0
)
return Settings.Instance.ColorProtectedHandles;
else if (Settings.Instance.UseColorInheritHandles &&
(item.Handle.Flags & HandleFlags.Inherit) != 0
)
return Settings.Instance.ColorInheritHandles;
else
return SystemColors.Window;
}
protected override void OnProcessException(HandleItem handleItem, ResultMessage result, Exception exc)
{
throw exc;
}
public void AddItem(HandleItem item)
{
provider_DictionaryAdded(item);
}
public void AddItem(HandleItem item)
{
provider_DictionaryAdded(item);
}
private void LoadHandles(MemoryObject mo)
{
var dict = Dump.GetDictionary(mo);
HandleItem item = new HandleItem();
if (!dict.ContainsKey("Handle"))
return;
item.Handle.ProcessId = _item.Pid;
item.Handle.Flags = (HandleFlags)Dump.ParseInt32(dict["Flags"]);
item.Handle.Handle = (short)Dump.ParseInt32(dict["Handle"]);
// Not really needed, just fill it in ignoring 32-bit vs 64-bit
// differences.
item.Handle.Object = (Dump.ParseInt64(dict["Object"]) & 0xffffffff).ToIntPtr();
item.Handle.GrantedAccess = Dump.ParseInt32(dict["GrantedAccess"]);
if (dict.ContainsKey("TypeName"))
{
item.ObjectInfo.TypeName = dict["TypeName"];
item.ObjectInfo.BestName = dict["ObjectName"];
}
if (Settings.Instance.HideHandlesWithNoName)
{
if (string.IsNullOrEmpty(item.ObjectInfo.BestName))
return;
}
listHandles.AddItem(item);
}
protected abstract void OnProcessException(HandleItem handleItem, ResultMessage result, Exception exc);
private void provider_DictionaryAdded(HandleItem item)
{
HighlightedListViewItem litem = new HighlightedListViewItem(_highlightingContext,
item.RunId > 0 && _runCount > 0);
litem.Name = item.Handle.Handle.ToString();
litem.Text = item.ObjectInfo.TypeName;
litem.SubItems.Add(new ListViewItem.ListViewSubItem(litem, item.ObjectInfo.BestName));
litem.SubItems.Add(new ListViewItem.ListViewSubItem(litem, "0x" + item.Handle.Handle.ToString("x")));
litem.Tag = item;
litem.NormalColor = this.GetHandleColor(item);
lock (_needsAdd)
_needsAdd.Add(litem);
}
private void provider_DictionaryRemoved(HandleItem item)
{
this.BeginInvoke(new MethodInvoker(() =>
{
lock (_listLock)
listHandles.Items[item.Handle.Handle.ToString()].Remove();
}));
}
private void provider_DictionaryModified(HandleItem oldItem, HandleItem newItem)
{
this.BeginInvoke(new MethodInvoker(() =>
{
lock (_listLock)
{
(listHandles.Items[newItem.Handle.Handle.ToString()] as
HighlightedListViewItem).NormalColor = this.GetHandleColor(newItem);
}
}));
}
