static private void InitCounters(string instance)
{
try { // try-filter-finally so and catch-throw
(new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Instrument, ".", SqlPerfCategory)).Assert();
try {
if (!ADP.IsEmpty(instance))
{
_connectionCount = new PerformanceCounter(SqlPerfCategory, SqlPerfConnections, instance, false);
_pooledConnectionCount = new PerformanceCounter(SqlPerfCategory, SqlPerfPooledConnections, instance, false);
_poolCount = new PerformanceCounter(SqlPerfCategory, SqlPerfConnectionPools, instance, false);
_peakPoolConnectionCount = new PerformanceCounter(SqlPerfCategory, SqlPerfPeakPoolConnections, instance, false);
_failedConnectCount = new PerformanceCounter(SqlPerfCategory, SqlPerfFailedConnects, instance, false);
_failedCommandCount = new PerformanceCounter(SqlPerfCategory, SqlPerfFailedCommands, instance, false);
}
// global perfcounters
_globalConnectionCount = new PerformanceCounter(SqlPerfCategory, SqlPerfConnections, Global, false);
_globalPooledConnectionCount = new PerformanceCounter(SqlPerfCategory, SqlPerfPooledConnections, Global, false);
_globalPoolCount = new PerformanceCounter(SqlPerfCategory, SqlPerfConnectionPools, Global, false);
// peakPoolConnectionCount does not apply to global
_globalFailedConnectCount = new PerformanceCounter(SqlPerfCategory, SqlPerfFailedConnects, Global, false);
_globalFailedCommandCount = new PerformanceCounter(SqlPerfCategory, SqlPerfFailedCommands, Global, false);
}
finally { // RevertAssert w/ catch-throw
PerformanceCounterPermission.RevertAssert();
}
}
catch { // MDAC 80973, 81286
throw;
}
}
public void Intersect_Null()
{
PerformanceCounterPermission pcp = new PerformanceCounterPermission(PermissionState.None);
// No intersection with null
Assert.IsNull(pcp.Intersect(null), "None N null");
}
public void PermissionState_Bad()
{
PermissionState ps = (PermissionState)77;
PerformanceCounterPermission pcp = new PerformanceCounterPermission(ps);
Assert.IsFalse(pcp.IsUnrestricted(), "IsUnrestricted");
}
public void PerformanceCounterPermissionAccesss_Bad()
{
PerformanceCounterPermissionAccess pcpa = (PerformanceCounterPermissionAccess)Int32.MinValue;
PerformanceCounterPermission pcp = new PerformanceCounterPermission(pcpa, "localhost", String.Empty);
Assert.AreEqual(1, pcp.PermissionEntries.Count, "Count");
Assert.AreEqual((PerformanceCounterPermissionAccess)Int32.MinValue, pcp.PermissionEntries [0].PermissionAccess, "PermissionAccess");
}
public void FromXml_WrongVersion()
{
PerformanceCounterPermission pcp = new PerformanceCounterPermission(PermissionState.None);
SecurityElement se = pcp.ToXml();
se.Attributes.Remove("version");
se.Attributes.Add("version", "2");
pcp.FromXml(se);
}
public void IsSubset_Self()
{
foreach (PerformanceCounterPermissionAccess pcpa in AllAccess)
{
PerformanceCounterPermission pcp = new PerformanceCounterPermission(PermissionState.None);
pcp.PermissionEntries.Add(new PerformanceCounterPermissionEntry(pcpa, pcpa.ToString(), String.Empty));
Assert.IsTrue(pcp.IsSubsetOf(pcp), pcpa.ToString());
}
}
public void IsSubset_Null()
{
PerformanceCounterPermission pcp = new PerformanceCounterPermission(PermissionState.None);
#if NET_2_0
Assert.IsTrue(pcp.IsSubsetOf(null), "null");
#else
Assert.IsFalse(pcp.IsSubsetOf(null), "null");
#endif
}
public void FromXml_WrongTagCase()
{
PerformanceCounterPermission pcp = new PerformanceCounterPermission(PermissionState.None);
SecurityElement se = pcp.ToXml();
se.Tag = "IPERMISSION"; // instead of IPermission
pcp.FromXml(se);
// note: normally IPermission classes (in corlib) DO care about the
// IPermission tag
}
internal CPerformanceCounterPermControls(IPermission perm, Object oParent) : base(perm, oParent)
{
// If they don't have a permission for this permission set, we will
// feed our property page a 'none' permission state.
if (perm == null)
{
m_perm = new PerformanceCounterPermission(PermissionState.None);
}
}// CPerformanceCounterPermControls
public void Union_Null()
{
PerformanceCounterPermission pcp = new PerformanceCounterPermission(PermissionState.None);
pcp.PermissionEntries.Add(new PerformanceCounterPermissionEntry(PerformanceCounterPermissionAccess.None, "localhost", String.Empty));
// Union with null is a simple copy
PerformanceCounterPermission union = (PerformanceCounterPermission)pcp.Union(null);
Assert.IsNotNull(pcp.PermissionEntries.Count, "Count");
}
public void FromXml_NoVersion()
{
PerformanceCounterPermission pcp = new PerformanceCounterPermission(PermissionState.None);
SecurityElement se = pcp.ToXml();
SecurityElement w = new SecurityElement(se.Tag);
w.AddAttribute("class", se.Attribute("class"));
pcp.FromXml(w);
}
}// CreateDataTable
protected override void PutValuesinPage()
{
// Put in the text for the radio buttons
m_radUnrestricted.Text = CResourceStore.GetString("PerformanceCounterPerm:GrantUnrestrict");
m_radGrantFollowingPermission.Text = CResourceStore.GetString("PerformanceCounterPerm:GrantFollowing");
PerformanceCounterPermission perm = (PerformanceCounterPermission)m_perm;
CheckUnrestricted(perm);
if (!perm.IsUnrestricted())
{
// Run through the list of socket permissions we have to accept connections
IEnumerator enumer = perm.PermissionEntries.GetEnumerator();
while (enumer.MoveNext())
{
PerformanceCounterPermissionEntry pcpe = (PerformanceCounterPermissionEntry)enumer.Current;
DataRow newRow;
newRow = m_dt.NewRow();
newRow["Machine"] = pcpe.MachineName;
newRow["Category"] = pcpe.CategoryName;
// Determine the Access String
String sAccess = null;
if ((pcpe.PermissionAccess & PerformanceCounterPermissionAccess.Administer) == PerformanceCounterPermissionAccess.Administer)
{
sAccess = CResourceStore.GetString("PerformanceCounterPermission:Administer");
}
else if ((pcpe.PermissionAccess & PerformanceCounterPermissionAccess.Instrument) == PerformanceCounterPermissionAccess.Instrument)
{
sAccess = CResourceStore.GetString("PerformanceCounterPermission:Instrument");
}
else if ((pcpe.PermissionAccess & PerformanceCounterPermissionAccess.Browse) == PerformanceCounterPermissionAccess.Browse)
{
sAccess = CResourceStore.GetString("PerformanceCounterPermission:Browse");
}
else
{
sAccess = CResourceStore.GetString("None");
}
newRow["Access"] = new DataGridComboBoxEntry(sAccess);
m_dt.Rows.Add(newRow);
}
}
// We want at least 1 row so it looks pretty
while (m_dt.Rows.Count < 1)
{
AddEmptyRow(m_dt);
}
}// PutValuesinPage
public void Union_Self()
{
foreach (PerformanceCounterPermissionAccess pcpa in AllAccess)
{
PerformanceCounterPermission pcp = new PerformanceCounterPermission(PermissionState.None);
pcp.PermissionEntries.Add(new PerformanceCounterPermissionEntry(pcpa, pcpa.ToString(), String.Empty));
PerformanceCounterPermission union = (PerformanceCounterPermission)pcp.Union(pcp);
Assert.IsFalse(union.IsUnrestricted(), "IsUnrestricted " + pcpa.ToString());
Assert.AreEqual(1, union.PermissionEntries.Count, "Count " + pcpa.ToString());
}
}
public void FromXml_NoClass()
{
PerformanceCounterPermission pcp = new PerformanceCounterPermission(PermissionState.None);
SecurityElement se = pcp.ToXml();
SecurityElement w = new SecurityElement(se.Tag);
w.AddAttribute("version", se.Attribute("version"));
pcp.FromXml(w);
// doesn't even care of the class attribute presence
}
public void Copy()
{
foreach (PerformanceCounterPermissionAccess pcpa in AllAccess)
{
PerformanceCounterPermission pcp = new PerformanceCounterPermission(PermissionState.None);
PerformanceCounterPermissionEntry pcpe = new PerformanceCounterPermissionEntry(pcpa, pcpa.ToString(), String.Empty);
pcp.PermissionEntries.Add(pcpe);
PerformanceCounterPermission copy = (PerformanceCounterPermission)pcp.Copy();
Assert.AreEqual(1, copy.PermissionEntries.Count, "Count==1");
Assert.AreEqual(pcpa, pcp.PermissionEntries [0].PermissionAccess, pcpa.ToString());
}
}
protected virtual bool UserHasAccessRights(string catagory)
{
PerformanceCounterPermission permissions = new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Write, ".", catagory);
permissions.Demand();
if (!PerformanceCounterCategory.Exists(catagory, "."))
{
return(false);
}
return(true);
}
public void Unrestricted()
{
PerformanceCounterPermissionAttribute a = new PerformanceCounterPermissionAttribute(SecurityAction.Assert);
a.Unrestricted = true;
PerformanceCounterPermission wp = (PerformanceCounterPermission)a.CreatePermission();
Assert.IsTrue(wp.IsUnrestricted(), "IsUnrestricted");
a.Unrestricted = false;
wp = (PerformanceCounterPermission)a.CreatePermission();
Assert.IsFalse(wp.IsUnrestricted(), "!IsUnrestricted");
}
public void Default()
{
PerformanceCounterPermissionAttribute a = new PerformanceCounterPermissionAttribute(SecurityAction.Assert);
Assert.AreEqual(a.ToString(), a.TypeId.ToString(), "TypeId");
Assert.IsFalse(a.Unrestricted, "Unrestricted");
Assert.AreEqual(".", a.MachineName, "MachineName");
Assert.AreEqual("*", a.CategoryName, "CategoryName");
Assert.AreEqual(PerformanceCounterPermissionAccess.Write, a.PermissionAccess, "PermissionAccess");
PerformanceCounterPermission sp = (PerformanceCounterPermission)a.CreatePermission();
Assert.IsFalse(sp.IsUnrestricted(), "IsUnrestricted");
}
public void FromXml_WrongClass()
{
PerformanceCounterPermission pcp = new PerformanceCounterPermission(PermissionState.None);
SecurityElement se = pcp.ToXml();
SecurityElement w = new SecurityElement(se.Tag);
w.AddAttribute("class", "Wrong" + se.Attribute("class"));
w.AddAttribute("version", se.Attribute("version"));
pcp.FromXml(w);
// doesn't care of the class name at that stage
// anyway the class has already be created so...
}
public void IsSubset_None()
{
// IsSubset with none
// a. source (this) is none -> target is never a subset
// b. destination (target) is none -> target is always a subset
PerformanceCounterPermission pcp1 = new PerformanceCounterPermission(PermissionState.None);
foreach (PerformanceCounterPermissionAccess pcpa in AllAccess)
{
PerformanceCounterPermission pcp2 = new PerformanceCounterPermission(PermissionState.None);
pcp2.PermissionEntries.Add(new PerformanceCounterPermissionEntry(pcpa, pcpa.ToString(), String.Empty));
Assert.IsTrue(pcp1.IsSubsetOf(pcp2), "target " + pcpa.ToString());
Assert.IsFalse(pcp2.IsSubsetOf(pcp1), "source " + pcpa.ToString());
}
}
public void Intersect_None()
{
PerformanceCounterPermission pcp1 = new PerformanceCounterPermission(PermissionState.None);
PerformanceCounterPermission pcp2 = new PerformanceCounterPermission(PermissionState.None);
// 1. None N None
PerformanceCounterPermission result = (PerformanceCounterPermission)pcp1.Intersect(pcp2);
Assert.IsNull(result, "Empty N Empty");
// 2. None N Entry
pcp2.PermissionEntries.Add(new PerformanceCounterPermissionEntry(PerformanceCounterPermissionAccess.None, "localhost", String.Empty));
result = (PerformanceCounterPermission)pcp1.Intersect(pcp2);
Assert.IsNull(result, "Empty N Entry");
// 3. Entry N None
result = (PerformanceCounterPermission)pcp2.Intersect(pcp1);
Assert.IsNull(result, "Entry N Empty");
}
public void Union_None()
{
PerformanceCounterPermission pcp1 = new PerformanceCounterPermission(PermissionState.None);
foreach (PerformanceCounterPermissionAccess pcpa in AllAccess)
{
PerformanceCounterPermission pcp2 = new PerformanceCounterPermission(PermissionState.None);
pcp2.PermissionEntries.Add(new PerformanceCounterPermissionEntry(pcpa, pcpa.ToString(), String.Empty));
PerformanceCounterPermission union = (PerformanceCounterPermission)pcp1.Union(pcp2);
Assert.IsFalse(union.IsUnrestricted(), "target.IsUnrestricted " + pcpa.ToString());
Assert.AreEqual(1, union.PermissionEntries.Count, "target.Count " + pcpa.ToString());
union = (PerformanceCounterPermission)pcp2.Union(pcp1);
Assert.IsFalse(union.IsUnrestricted(), "source.IsUnrestricted " + pcpa.ToString());
Assert.AreEqual(1, union.PermissionEntries.Count, "source.Count " + pcpa.ToString());
}
}
public void PermissionState_Unrestricted()
{
PermissionState ps = PermissionState.Unrestricted;
PerformanceCounterPermission pcp = new PerformanceCounterPermission(ps);
Assert.AreEqual(0, pcp.PermissionEntries.Count, "PermissionEntries");
Assert.IsTrue(pcp.IsUnrestricted(), "IsUnrestricted");
SecurityElement se = pcp.ToXml();
// only class and version are present
Assert.AreEqual("true", se.Attribute("Unrestricted"), "Xml-Unrestricted");
Assert.IsNull(se.Children, "Xml-Children");
PerformanceCounterPermission copy = (PerformanceCounterPermission)pcp.Copy();
Assert.IsFalse(Object.ReferenceEquals(pcp, copy), "ReferenceEquals");
Assert.AreEqual(pcp.PermissionEntries.Count, copy.PermissionEntries.Count, "copy-PermissionEntries");
Assert.AreEqual(pcp.IsUnrestricted(), copy.IsUnrestricted(), "copy-IsUnrestricted ()");
}
public void PermissionEntries()
{
PerformanceCounterPermissionAccess pcpa = PerformanceCounterPermissionAccess.None;
PerformanceCounterPermission pcp = new PerformanceCounterPermission(pcpa, "localhost", String.Empty);
PerformanceCounterPermissionEntryCollection pcpec = pcp.PermissionEntries;
Assert.AreEqual(1, pcpec.Count, "Count==1");
PerformanceCounterPermissionEntry pcpe = new PerformanceCounterPermissionEntry(PerformanceCounterPermissionAccess.Browse, "*", String.Empty);
pcp.PermissionEntries.Add(pcpe);
Assert.AreEqual(2, pcpec.Count, "Count==2");
// remove (same instance)
pcp.PermissionEntries.Remove(pcpe);
Assert.AreEqual(1, pcpec.Count, "Count==1 (b)");
// remove different instance (doesn't work)
pcpe = new PerformanceCounterPermissionEntry(PerformanceCounterPermissionAccess.None, "localhost", String.Empty);
Assert.AreEqual(1, pcpec.Count, "Count==1");
}
public void Intersect_Unrestricted()
{
// Intersection with unrestricted == Copy
// a. source (this) is unrestricted
PerformanceCounterPermission pcp1 = new PerformanceCounterPermission(PermissionState.Unrestricted);
PerformanceCounterPermission pcp2 = new PerformanceCounterPermission(PermissionState.None);
// 1. Unrestricted N None
PerformanceCounterPermission result = (PerformanceCounterPermission)pcp1.Intersect(pcp2);
Assert.IsFalse(result.IsUnrestricted(), "(Unrestricted N None).IsUnrestricted");
Assert.AreEqual(0, result.PermissionEntries.Count, "(Unrestricted N None).Count");
// 2. None N Unrestricted
result = (PerformanceCounterPermission)pcp2.Intersect(pcp1);
Assert.IsFalse(result.IsUnrestricted(), "(None N Unrestricted).IsUnrestricted");
Assert.AreEqual(0, result.PermissionEntries.Count, "(None N Unrestricted).Count");
// 3. Unrestricted N Unrestricted
result = (PerformanceCounterPermission)pcp1.Intersect(pcp1);
Assert.IsTrue(result.IsUnrestricted(), "(Unrestricted N Unrestricted).IsUnrestricted");
Assert.AreEqual(0, result.PermissionEntries.Count, "(Unrestricted N Unrestricted).Count");
// 4. Unrestricted N Entry
pcp2.PermissionEntries.Add(new PerformanceCounterPermissionEntry(PerformanceCounterPermissionAccess.None, "localhost", String.Empty));
result = (PerformanceCounterPermission)pcp1.Intersect(pcp2);
Assert.IsFalse(result.IsUnrestricted(), "(Unrestricted N Entry).IsUnrestricted");
Assert.AreEqual(1, result.PermissionEntries.Count, "(Unrestricted N Entry).Count");
// 5. Entry N Unrestricted
result = (PerformanceCounterPermission)pcp2.Intersect(pcp1);
Assert.IsFalse(result.IsUnrestricted(), "(Entry N Unrestricted).IsUnrestricted");
Assert.AreEqual(1, result.PermissionEntries.Count, "(Entry N Unrestricted).Count");
// 6. Unrestricted N Unrestricted
pcp1.PermissionEntries.Add(new PerformanceCounterPermissionEntry(PerformanceCounterPermissionAccess.None, "localhost", String.Empty));
result = (PerformanceCounterPermission)pcp1.Intersect(pcp1);
Assert.IsTrue(result.IsUnrestricted(), "(Unrestricted N Unrestricted).IsUnrestricted");
Assert.AreEqual(1, result.PermissionEntries.Count, "(Unrestricted N Unrestricted).Count");
}
public void Constructor_MachineName_Null()
{
PerformanceCounterPermission pcp = new PerformanceCounterPermission(PerformanceCounterPermissionAccess.None, null, String.Empty);
}
public void Constructor_CategoryName_Null()
{
PerformanceCounterPermission pcp = new PerformanceCounterPermission(PerformanceCounterPermissionAccess.None, "localhost", null);
}
public void FromXml_Null()
{
PerformanceCounterPermission pcp = new PerformanceCounterPermission(PermissionState.None);
pcp.FromXml(null);
}
public void Union_BadPermission()
{
PerformanceCounterPermission pcp1 = new PerformanceCounterPermission(PermissionState.Unrestricted);
pcp1.Union(new SecurityPermission(SecurityPermissionFlag.Assertion));
}
// "special" behavior inherited from ResourceBasePermission
// [ExpectedException (typeof (ArgumentException))]
public void IsSubsetOf_BadPermission()
{
PerformanceCounterPermission pcp1 = new PerformanceCounterPermission(PermissionState.Unrestricted);
Assert.IsFalse(pcp1.IsSubsetOf(new SecurityPermission(SecurityPermissionFlag.Assertion)));
}
