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))); }