public PerfCounter Groups; // # of entities tracked /// <summary> /// Initializes the service's performance counters from the performance /// counter set passed. /// </summary> /// <param name="perfCounters">The application's performance counter set (or <c>null</c>).</param> /// <param name="perfPrefix">The string to prefix any performance counter names (or <c>null</c>).</param> public Perf(PerfCounterSet perfCounters, string perfPrefix) { Install(perfCounters, perfPrefix); if (perfPrefix == null) { perfPrefix = string.Empty; } if (perfCounters != null) { IPGeocode = perfCounters[perfPrefix + IPGeocode_Name]; FixesReceived = perfCounters[perfPrefix + FixesReceived_Name]; FixesArchived = perfCounters[perfPrefix + FixesArchived_Name]; Runtime = perfCounters[perfPrefix + Runtime_Name]; Entities = perfCounters[perfPrefix + Entities_Name]; Groups = perfCounters[perfPrefix + Groups_Name]; } else { IPGeocode = FixesReceived = FixesArchived = Runtime = Entities = Groups = PerfCounter.Stub; } }
public void PerfCounterSet_Install_Uninstall() { PerfCounterSet counters = new PerfCounterSet(false, true, "Test_Install_Uninstall", "Test Help"); PerfCounter A, B; try { counters.Add(new PerfCounter("A", "A Help", PerformanceCounterType.NumberOfItems32)); counters.Add(new PerfCounter("B", "B Help", PerformanceCounterType.NumberOfItems32)); counters.Install(); A = counters["A"]; Assert.IsNotNull(A.Counter); Assert.AreEqual(0, A.RawValue); Assert.AreEqual(1, A.Increment()); Assert.AreEqual(1, A.RawValue); B = counters["B"]; B.IncrementBy(55); Assert.AreEqual(55, B.RawValue); } finally { counters.Uninstall(); } }
public void PerfCounterSet_Related2() { PerfCounterSet counters = new PerfCounterSet(false, true, "Test_Related2", "Test Help"); PerfCounter A, B, C; try { counters.Add(new PerfCounter("A", "A Help", PerformanceCounterType.NumberOfItems32)); counters.Add(new PerfCounter("B", "B Help", PerformanceCounterType.NumberOfItems32)); counters.Add(new PerfCounter("C", "C Help", PerformanceCounterType.NumberOfItems32)); counters.Relate("A", "C"); counters.Relate("B", "C"); counters.Install(); A = counters["A"]; B = counters["B"]; C = counters["C"]; Assert.AreEqual(0, C.RawValue); A.Increment(); Assert.AreEqual(1, C.RawValue); B.IncrementBy(5); Assert.AreEqual(6, C.RawValue); A.Decrement(); Assert.AreEqual(5, C.RawValue); } finally { counters.Uninstall(); } }
/// <summary> /// Installs the service's performance counters by adding them to the /// performance counter set passed. /// </summary> /// <param name="perfCounters">The application's performance counter set (or <c>null</c>).</param> /// <param name="perfPrefix">The string to prefix any performance counter names (or <c>null</c>).</param> public static void Install(PerfCounterSet perfCounters, string perfPrefix) { if (perfCounters == null) { return; } if (perfPrefix == null) { perfPrefix = string.Empty; } perfCounters.Add(new PerfCounter(perfPrefix + IsMaster_Name, "Indicates if this is the cluster master (0/1)", PerformanceCounterType.NumberOfItems32)); perfCounters.Add(new PerfCounter(perfPrefix + AdminMessageRate_Name, "Admin Messages/sec", PerformanceCounterType.RateOfCountsPerSecond32)); perfCounters.Add(new PerfCounter(perfPrefix + AdminByteRate_Name, "Admin Bytes/sec", PerformanceCounterType.RateOfCountsPerSecond32)); perfCounters.Add(new PerfCounter(perfPrefix + BroadcastReceiveMessageRate_Name, "Broadcast Messages Received/sec", PerformanceCounterType.RateOfCountsPerSecond32)); perfCounters.Add(new PerfCounter(perfPrefix + BroadcastReceiveByteRate_Name, "Broadcast Receive Bytes/sec", PerformanceCounterType.RateOfCountsPerSecond32)); perfCounters.Add(new PerfCounter(perfPrefix + BroadcastSendMessageRate_Name, "Broadcast Messages Sent/sec", PerformanceCounterType.RateOfCountsPerSecond32)); perfCounters.Add(new PerfCounter(perfPrefix + BroadcastSendByteRate_Name, "Broadcast Send Bytes/sec", PerformanceCounterType.RateOfCountsPerSecond32)); perfCounters.Add(new PerfCounter(perfPrefix + TotalMessageRate_Name, "Total Messages (sent or received)/sec", PerformanceCounterType.RateOfCountsPerSecond32)); perfCounters.Add(new PerfCounter(perfPrefix + TotalByteRate_Name, "Total Bytes (sent or received)/sec", PerformanceCounterType.RateOfCountsPerSecond32)); perfCounters.Add(new PerfCounter(perfPrefix + ServerCount_Name, "Number of UDP broadcast servers in the cluster", PerformanceCounterType.NumberOfItems32)); perfCounters.Add(new PerfCounter(perfPrefix + ClientCount_Name, "Number of UDP broadcast clients in the cluster", PerformanceCounterType.NumberOfItems32)); perfCounters.Add(new PerfCounter(perfPrefix + Runtime_Name, "Service runtime in minutes", PerformanceCounterType.NumberOfItems32)); }
public void PerfCounterSet_Instances() { PerfCounterSet counters = new PerfCounterSet(true, true, "Test_Instances", "Test Help"); PerfCounter A_ONE, A_TWO, B_ONE, B_TWO; try { counters.Add(new PerfCounter("A", "A Help", PerformanceCounterType.NumberOfItems32)); counters.Add(new PerfCounter("B", "B Help", PerformanceCounterType.NumberOfItems32)); counters.Install(); A_ONE = counters["A", "ONE"]; A_TWO = counters["A", "TWO"]; B_ONE = counters["B", "ONE"]; B_TWO = counters["B", "TWO"]; A_ONE.IncrementBy(1); A_TWO.IncrementBy(2); B_ONE.IncrementBy(3); B_TWO.IncrementBy(4); Assert.AreEqual(1, A_ONE.RawValue); Assert.AreEqual(2, A_TWO.RawValue); Assert.AreEqual(3, B_ONE.RawValue); Assert.AreEqual(4, B_TWO.RawValue); } finally { counters.Uninstall(); } }
/// <summary> /// Installs the service's performance counters by adding them to the /// performance counter set passed. /// </summary> /// <param name="perfCounters">The application's performance counter set (or <c>null</c>).</param> public static void Install(PerfCounterSet perfCounters) { if (perfCounters == null) { return; } perfCounters.Add(new PerfCounter(Runtime_Name, "Service runtime in minutes", PerformanceCounterType.NumberOfItems32)); perfCounters.Add(new PerfCounter(TotalCalls_Name, "Total active calls", PerformanceCounterType.NumberOfItems32)); perfCounters.Add(new PerfCounter(TotalCallRate_Name, "Total Call Rate", PerformanceCounterType.RateOfCountsPerSecond32)); }
/// <summary> /// Associates the service handler with a message router by registering /// the necessary application message handlers. /// </summary> /// <param name="router">The message router.</param> /// <param name="settings">The configuration settings.</param> /// <param name="perfCounters">The application's performance counter set (or <c>null</c>).</param> /// <param name="perfPrefix">The string to prefix any performance counter names (or <c>null</c>).</param> /// <remarks> /// <para> /// Applications that expose performance counters will pass a non-<c>null</c> <b>perfCounters</b> /// instance. The service handler should add any counters it implements to this set. /// If <paramref name="perfPrefix" /> is not <c>null</c> then any counters added should prefix their /// names with this parameter. /// </para> /// </remarks> public void Start(MsgRouter router, GeoTrackerServerSettings settings, PerfCounterSet perfCounters, string perfPrefix) { if (this.isRunning) { throw new InvalidOperationException("This node has already been started."); } if (router == null) { throw new ArgumentNullException("router"); } // Initialize the performance counters this.startTime = DateTime.UtcNow; this.perf = new Perf(perfCounters, perfPrefix); // General initialization this.settings = settings; this.bkTimer = new GatedTimer(new TimerCallback(OnBkTimer), null, settings.BkInterval); this.ipGeocoder = new IPGeocoder(this); this.clusterClient = Helper.CreateInstance <ITopologyProvider>(settings.ClusterTopology); this.clusterServer = Helper.CreateInstance <ITopologyProvider>(settings.ClusterTopology); this.fixCache = new GeoFixCache(settings); this.archiver = Helper.CreateInstance <IGeoFixArchiver>(settings.GeoFixArchiver); EntityState.MaxEntityFixes = settings.MaxEntityGeoFixes; try { // Initialize the router this.router = router; this.router.Dispatcher.AddTarget(this, "GeoTrackerServerEP", new SimpleEPMunger(settings.ServerEP), null); // Initialize the cluster this.clusterClient.OpenClient(router, settings.ClusterEP, settings.ClusterArgs); this.clusterServer.OpenServer(router, "GeoTrackerClusterEP", settings.ClusterEP, this, settings.ClusterArgs); // Start the archiver. archiver.Start(this, settings.GeoFixArchiverArgs); this.isRunning = true; } catch { Stop(); throw; } }
/// <summary> /// Associates the service handler with a message router by registering /// the necessary application message handlers. /// </summary> /// <param name="router">The message router.</param> /// <param name="keyPrefix">The configuration key prefix or (null to use <b>LillTek.Datacenter.ConfigService</b>).</param> /// <param name="perfCounters">The application's performance counter set (or <c>null</c>).</param> /// <param name="perfPrefix">The string to prefix any performance counter names (or <c>null</c>).</param> /// <remarks> /// <para> /// Applications that expose performance counters will pass a non-<c>null</c> <b>perfCounters</b> /// instance. The service handler should add any counters it implements to this set. /// If <paramref name="perfPrefix" /> is not <c>null</c> then any counters added should prefix their /// names with this parameter. /// </para> /// </remarks> public void Start(MsgRouter router, string keyPrefix, PerfCounterSet perfCounters, string perfPrefix) { Config config; // Make sure that the LillTek.Datacenter message types have been // registered with the LillTek.Messaging subsystem. LillTek.Datacenter.Global.RegisterMsgTypes(); // Verify the router parameter if (router == null) { throw new ArgumentNullException("router", "Router cannot be null."); } if (this.router != null) { throw new InvalidOperationException("This handler has already been started."); } // Determine the location of the settings folder if (keyPrefix == null) { keyPrefix = ConfigPrefix; } config = new Config(keyPrefix); settingsFolder = config.Get("SettingsFolder"); if (settingsFolder == null) { settingsFolder = Helper.EntryAssemblyFolder + Helper.PathSepString + "Settings"; } if (!settingsFolder.EndsWith(Helper.PathSepString)) { settingsFolder += Helper.PathSepString; } if (!Directory.Exists(settingsFolder.Substring(0, settingsFolder.Length - 1))) { throw new FileNotFoundException(string.Format("Settings folder [{0}] does not exist.", settingsFolder)); } // Register the handler and get ready to accept client requests this.router = router; router.Dispatcher.AddTarget(this); }
/// <summary> /// Handles the performance counter installation if they don't /// already exist. /// </summary> /// <returns>The application's <see cref="PerfCounterSet" />.</returns> public static PerfCounterSet InstallPerfCounters() { bool exists = PerformanceCounterCategory.Exists(Const.DynDnsClientPerf); PerfCounterSet perfCounters; perfCounters = new PerfCounterSet(false, true, Const.DynDnsClientPerf, Const.DynDnsClientName); if (!exists) { perfCounters.Install(); } return(perfCounters); }
/// <summary> /// Establishes a session with the authentication extension. /// </summary> /// <param name="args">The extension specific arguments (see the remarks).</param> /// <param name="query">Not used.</param> /// <param name="perfCounters">The application's performance counter set (or <c>null</c>).</param> /// <param name="perfPrefix">The string to prefix any performance counter names (or <c>null</c>).</param> /// <remarks> /// <para> /// This extension recognises the following arguments: /// </para> /// <list type="table"> /// <item> /// <term>IsAD</term> /// <description> /// Set this to "true" or "yes" if the directory server is Microsoft Active Directory. /// This argument defaults to "true". /// </description> /// </item> /// <item> /// <term>AuthType</term> /// <description> /// Specifies the authentication method. The possible values are <b>Basic</b>, <b>Digest</b>, /// <b>DPA</b>, <b>External</b>, <b>Kerberos</b>, <b>MSN</b>, <b>Negotiate</b>, <b>NTLM</b>, /// or <b>Sicily</b>. This argument defaults to "Digest". /// </description> /// </item> /// <item> /// <term>Servers</term> /// <description> /// Specifies zero or more LDAP server host names or IP addresses separated by commas. /// This argument defaults an empty list. <b>Note that due to an unresolved bug with /// default Active Directory support, at least one LDAP server must be explicitly /// specified in the current build.</b> /// </description> /// </item> /// <item> /// <term>DNSHost</term> /// <description> /// Set this to "true" or "yes" if the host names specified by <b>Servers</b> should be /// interpreted as fully qualified DNS host names. If set to "no" or "false", the /// host names can be interpreted as an IP address or a DNS host name and if no host /// is specified, then an Active Directory server associated with the computer account /// will be used. This argument defaults to "false". /// </description> /// </item> /// <item> /// <term>UDP</term> /// <description> /// Set this to "true" or "yes" to enable UDP the connection over UDP, rather than over TCP/IP. /// This argument defaults to "false". /// </description> /// </item> /// <item> /// <term>MaxCacheTime</term> /// <description> /// Specifies the maximum time clients should retain authentication information. /// This is expressed in the same format as timespans parsed by <see cref="Config.Parse(string,TimeSpan)" />. /// This argument defaults to "5m". /// </description> /// </item> /// <item> /// <term>LockoutCount</term> /// <description> /// Specifies the limiting failed authentication count. Accounts /// will be locked when the fail count reaches this number. /// </description> /// </item> /// <item> /// <term>LockoutThreshold</term> /// <description> /// The period of time that can elapse between failed authentication /// attempts where the failed attempts will <b>not</b> be counted against the /// <b>LockoutCount</b>. Set this to <see cref="TimeSpan.Zero" /> /// to disable account lockout for the realm. /// </description> /// </item> /// <item> /// <term>LockoutTime</term> /// <description> /// The period of time an account will remain locked after being locked /// out due to too many failed authentication attempts. /// </description> /// </item> /// </list> /// <para> /// The defaults values for the arguments were selected so that ommiting all arguments /// will configure the extension so that it authenticates against the Active Directory /// domain the computer belongs to. There are some problems with some combinations of /// parameters. /// </para> /// <note> /// All calls to <see cref="Open" /> must be matched with a call /// to <see cref="Close" /> or <see cref="Dispose" />. /// </note> /// </remarks> public void Open(ArgCollection args, string query, PerfCounterSet perfCounters, string perfPrefix) { using (TimedLock.Lock(this)) { if (IsOpen) { throw new AuthenticationException("Authentication extension is already open."); } perf = new Perf(perfCounters, perfPrefix); // Load the arguments isAD = args.Get("IsAD", true); switch (args.Get("AuthType", "Digest").ToUpper()) { case "BASIC": authType = AuthType.Basic; break; case "DIGEST": authType = AuthType.Digest; break; case "DPA": authType = AuthType.Dpa; break; case "EXTERNAL": authType = AuthType.External; break; case "KERBEROS": authType = AuthType.Kerberos; break; case "MSN": authType = AuthType.Msn; break; case "NEGOTIATE": authType = AuthType.Negotiate; break; case "NTLM": authType = AuthType.Ntlm; break; case "SICILY": authType = AuthType.Sicily; break; default: throw new AuthenticationException("Unexpected authentication type argument [{0}].", args.Get("AuthType", "Negotiate")); } servers = args.Get("Servers", string.Empty).Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries); for (int i = 0; i < servers.Length; i++) { servers[i] = servers[i].Trim(); } dnsHosts = args.Get("DNSHost", false); udp = args.Get("UDP", false); maxCacheTime = args.Get("MaxCacheTime", TimeSpan.FromMinutes(5)); } }
/// <summary> /// Establishes a session with the authentication extension. /// </summary> /// <param name="args">The extension specific arguments (see the remarks).</param> /// <param name="query">Ignored for this extension.</param> /// <param name="perfCounters">The application's performance counter set (or <c>null</c>).</param> /// <param name="perfPrefix">The string to prefix any performance counter names (or <c>null</c>).</param> /// <remarks> /// <para> /// This extension recognises the following arguments: /// </para> /// <list type="table"> /// <item> /// <term>Servers</term> /// <description> /// Specifies the list of RADIUS server network bindings specifying the /// IP address or host name of the server as well as the port number /// or well-known port name. Each server binding is formatted as /// described by <see cref="NetworkBinding.Parse" /> and the server /// bindings are separated by commas. This argument must be present. /// </description> /// </item> /// <item> /// <term>Secret</term> /// <description> /// The shared secret to be used to secure RADIUS packets delivered /// between this client and the any of the RADIUS servers. This /// string may include any valid characters besides semi-colons. /// This argument must be present. /// </description> /// </item> /// <item> /// <term>SocketBuffer</term> /// <description> /// Byte size of the client socket's send and receive buffers. Default /// value is 32K. /// </description> /// </item> /// <item> /// <term>NetworkBinding</term> /// <description> /// <para> /// Specifies the IP address of the network card the client is /// and port bindings. Use an IP address of ANY to bind to /// all network interfaces. ANY is suitable for single homed machines. /// Machines that are actually connected to multiple networks should /// specify a specific network binding here to ensure that the NAS-IP-Address /// of RADIUS authentication packets are initialized properly. /// </para> /// <para> /// A specific port number may be selected or 0 can be specified, /// indicating that the operating system should select a free port. /// </para> /// <para> /// Default value is ANY:0. /// </para> /// </description> /// </item> /// <item> /// <term>PortCount</term> /// <description> /// The number of RADIUS client UDP ports to open. Multiple ports may /// be required under high authentication loads. Default value is 4. /// </description> /// </item> /// <item> /// <term>RetryInterval</term> /// <description> /// Maximum time to wait for a response packet from a RADIUS before retransmitting /// an authentication request. Default is 5 seconds. /// </description> /// </item> /// <item> /// <term></term> /// <description> /// </description> /// </item> /// <item> /// <term>BkTaskInterval</term> /// <description> /// The interval at which background tasks such as retransmitting /// a request should be processed. Default is 1 second. /// </description> /// </item> /// <item> /// <term>MaxTransmissions</term> /// <description> /// The maximum number of authentication transmission attempts before aborting /// with an authentication with a timeout. Default is 4. /// </description> /// </item> /// <item> /// <term>RealmFormat</term> /// <description> /// Specifies how user names are to be generated from the /// <b>realm</b> and <b>account</b> components. See /// <see cref="RealmFormat" /> for more information. /// The possible values are: <b>Slash</b> and <b>Email</b>. /// Default is <b>Email</b>. /// </description> /// </item> /// <item> /// <term>MaxCacheTime</term> /// <description> /// Specifies the maximum time clients should retain authentication information. /// This is expressed in the same format as timespans parsed by <see cref="Config.Parse(string,TimeSpan)" />. /// This argument defaults to "5m". /// </description> /// </item> /// <item> /// <term>LockoutCount</term> /// <description> /// Specifies the limiting failed authentication count. Accounts /// will be locked when the fail count reaches this number. /// </description> /// </item> /// <item> /// <term>LockoutThreshold</term> /// <description> /// The period of time that can elapse between failed authentication /// attempts where the failed attempts will <b>not</b> be counted against the /// <b>LockoutCount</b>. Set this to <see cref="TimeSpan.Zero" /> /// to disable account lockout for the realm. /// </description> /// </item> /// <item> /// <term>LockoutTime</term> /// <description> /// The period of time an account will remain locked after being locked /// out due to too many failed authentication attempts. /// </description> /// </item> /// </list> /// <note> /// All calls to <see cref="Open" /> must be matched with a call /// to <see cref="Close" /> or <see cref="Dispose" />. /// </note> /// </remarks> public void Open(ArgCollection args, string query, PerfCounterSet perfCounters, string perfPrefix) { RadiusClientSettings settings; string[] rawBindings; List <NetworkBinding> bindings; string secret; using (TimedLock.Lock(this)) { if (IsOpen) { throw new AuthenticationException("Authentication extension is already open."); } perf = new Perf(perfCounters, perfPrefix); rawBindings = args.Get("servers", string.Empty).Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries); if (rawBindings.Length == 0) { throw new AuthenticationException("RADUIS authentication extension requires at least one server network binding."); } bindings = new List <NetworkBinding>(rawBindings.Length); for (int i = 0; i < rawBindings.Length; i++) { bindings.Add(NetworkBinding.Parse(rawBindings[i])); } secret = args.Get("secret", (string)null); if (secret == null || secret.Length == 0) { throw new AuthenticationException("RADIUS authentication extension requires a shared NAS secret."); } settings = new RadiusClientSettings(bindings.ToArray(), secret); settings.SocketBuffer = args.Get("SocketBuffer", settings.SocketBuffer); settings.NetworkBinding = args.Get("NetworkBinding", settings.NetworkBinding); settings.PortCount = args.Get("PortCount", settings.PortCount); settings.RetryInterval = args.Get("RetryInterval", settings.RetryInterval); settings.BkTaskInterval = args.Get("BkTaskInterval", settings.BkTaskInterval); settings.MaxTransmissions = args.Get("settings.MaxTransmissions", settings.MaxTransmissions); settings.RealmFormat = args.Get <RealmFormat>("RealmFormat", settings.RealmFormat); maxCacheTime = args.Get("MaxCacheTime", TimeSpan.FromMinutes(5)); radiusClient.Open(settings); } }
/// <summary> /// Handles the performance counter installation if they don't /// already exist. /// </summary> /// <returns>The application's <see cref="PerfCounterSet" />.</returns> public static PerfCounterSet InstallPerfCounters() { bool exists = PerformanceCounterCategory.Exists(Const.BroadcastServerPerf); PerfCounterSet perfCounters; perfCounters = new PerfCounterSet(false, true, Const.BroadcastServerPerf, Const.BroadcastServerName); if (!exists) { UdpBroadcastServer.InstallPerfCounters(perfCounters, null); perfCounters.Install(); } return(perfCounters); }
/// <summary> /// Handles the performance counter installation if they don't /// already exist. /// </summary> /// <returns>The application's <see cref="PerfCounterSet" />.</returns> public static PerfCounterSet InstallPerfCounters() { bool exists = PerformanceCounterCategory.Exists(Const.MessageQueuePerf); PerfCounterSet perfCounters; perfCounters = new PerfCounterSet(false, true, Const.MessageQueuePerf, Const.MessageQueueName); if (!exists) { MsgQueueHandler.InstallPerfCounters(perfCounters, null); perfCounters.Install(); } return(perfCounters); }
/// <summary> /// Installs the service's performance counters by adding them to the /// performance counter set passed. /// </summary> /// <param name="perfCounters">The application's performance counter set (or <c>null</c>).</param> /// <param name="perfPrefix">The string to prefix any performance counter names (or <c>null</c>).</param> public static void Install(PerfCounterSet perfCounters, string perfPrefix) { if (perfCounters == null) { return; } if (perfPrefix == null) { perfPrefix = string.Empty; } perfCounters.Add(new PerfCounter(perfPrefix + Queries_Name, "RADIUS authentication queries/sec", PerformanceCounterType.RateOfCountsPerSecond32)); perfCounters.Add(new PerfCounter(perfPrefix + Exceptions_Name, "RADIUS exceptions/sec", PerformanceCounterType.RateOfCountsPerSecond32)); }
/// <summary> /// Handles the performance counter installation if they don't /// already exist. /// </summary> /// <returns>The application's <see cref="PerfCounterSet" />.</returns> public static PerfCounterSet InstallPerfCounters() { bool exists = PerformanceCounterCategory.Exists(Const.HeartbeatPerf); PerfCounterSet perfCounters; perfCounters = new PerfCounterSet(false, true, Const.HeartbeatPerf, Const.HeartbeatName); if (!exists) { HeartbeatHandler.InstallPerfCounters(perfCounters, null); perfCounters.Install(); } return(perfCounters); }
/// <summary> /// Handles the performance counter installation if they don't /// already exist. /// </summary> /// <returns>The application's <see cref="PerfCounterSet" />.</returns> public static PerfCounterSet InstallPerfCounters() { bool exists = PerformanceCounterCategory.Exists(SwitchConst.NeonSwitchPerf); PerfCounterSet perfCounters; perfCounters = new PerfCounterSet(false, true, SwitchConst.NeonSwitchPerf, SwitchConst.NeonSwitchName); if (!exists) { CorePerf.Install(perfCounters); perfCounters.Install(); } return(perfCounters); }
/// <summary> /// Installs the service's performance counters by adding them to the /// performance counter set passed. /// </summary> /// <param name="perfCounters">The application's performance counter set (or <c>null</c>).</param> /// <param name="perfPrefix">The string to prefix any performance counter names (or <c>null</c>).</param> public static void Install(PerfCounterSet perfCounters, string perfPrefix) { if (perfCounters == null) { return; } if (perfPrefix == null) { perfPrefix = string.Empty; } perfCounters.Add(new PerfCounter(perfPrefix + Queries_Name, "Number of health check queries/sec", PerformanceCounterType.RateOfCountsPerSecond32)); perfCounters.Add(new PerfCounter(perfPrefix + Status_Name, "Health Status (1=healthy)", PerformanceCounterType.NumberOfItems32)); perfCounters.Add(new PerfCounter(perfPrefix + Runtime_Name, "Service runtime in minutes", PerformanceCounterType.NumberOfItems32)); }
/// <summary> /// Handles the performance counter installation if they don't /// already exist. /// </summary> /// <returns>The application's <see cref="PerfCounterSet" />.</returns> public static PerfCounterSet InstallPerfCounters() { bool exists = PerformanceCounterCategory.Exists(Const.GeoTrackerPerf); PerfCounterSet perfCounters; perfCounters = new PerfCounterSet(false, true, Const.GeoTrackerPerf, Const.GeoTrackerName); if (!exists) { GeoTrackerNode.InstallPerfCounters(perfCounters, null); perfCounters.Install(); } return(perfCounters); }
/// <summary> /// Installs the service's performance counters by adding them to the /// performance counter set passed. /// </summary> /// <param name="perfCounters">The application's performance counter set (or <c>null</c>).</param> /// <param name="perfPrefix">The string to prefix any performance counter names (or <c>null</c>).</param> public static void Install(PerfCounterSet perfCounters, string perfPrefix) { if (perfCounters == null) { return; } if (perfPrefix == null) { perfPrefix = string.Empty; } perfCounters.Add(new PerfCounter(perfPrefix + Uploads_Name, "Application executable packages received/sec", PerformanceCounterType.RateOfCountsPerSecond32)); perfCounters.Add(new PerfCounter(perfPrefix + Deliveries_Name, "Application executable packages deliveries/sec", PerformanceCounterType.RateOfCountsPerSecond32)); perfCounters.Add(new PerfCounter(perfPrefix + CacheLoads_Name, "Application executable package cache loads/sec", PerformanceCounterType.RateOfCountsPerSecond32)); perfCounters.Add(new PerfCounter(perfPrefix + Runtime_Name, "Service runtime in minutes", PerformanceCounterType.NumberOfItems32)); }
/// <summary> /// Establishes a session with the authentication extension. /// </summary> /// <param name="args">The extension specific arguments (see the remarks).</param> /// <param name="query">Ignored for this extension.</param> /// <param name="perfCounters">The application's performance counter set (or <c>null</c>).</param> /// <param name="perfPrefix">The string to prefix any performance counter names (or <c>null</c>).</param> /// <remarks> /// <para> /// This extension recognises the following arguments: /// </para> /// <list type="table"> /// <item> /// <term>Key</term> /// <description> /// The fully qualified name of the configuration key array with the credentials. /// </description> /// </item> /// <item> /// <term>MaxCacheTime</term> /// <description> /// Specifies the maximum time clients should retain authentication information. /// This is expressed in the same format as timespans parsed by <see cref="Config.Parse(string,TimeSpan)" />. /// This argument defaults to "5m". /// </description> /// </item> /// <item> /// <term>LockoutCount</term> /// <description> /// Specifies the limiting failed authentication count. Accounts /// will be locked when the fail count reaches this number. /// </description> /// </item> /// <item> /// <term>LockoutThreshold</term> /// <description> /// The period of time that can elapse between failed authentication /// attempts where the failed attempts will <b>not</b> be counted against the /// <b>LockoutCount</b>. Set this to <see cref="TimeSpan.Zero" /> /// to disable account lockout for the realm. /// </description> /// </item> /// <item> /// <term>LockoutTime</term> /// <description> /// The period of time an account will remain locked after being locked /// out due to too many failed authentication attempts. /// </description> /// </item> /// </list> /// <para> /// The credentials are loaded from a configuration array holding a list /// of accounts, one array element, with the account fields separated by semicolons. /// The required fields are <b>Realm</b>, <b>Account</b>, and <b>Password</b> /// in that order. Here's an example: /// </para> /// <code language="none"> /// Accounts[0] = lilltek.com;jeff.lill;foobar /// Accounts[1] = lilltek.com;joe.blow;little.debbie /// Accounts[2] = lilltek.com;jane.doe;fancy.pants /// Accounts[3] = amex.com;[email protected];password.123 /// </code> /// <note> /// All calls to <see cref="Open" /> must be matched with a call /// to <see cref="Close" /> or <see cref="Dispose" />. /// </note> /// </remarks> public void Open(ArgCollection args, string query, PerfCounterSet perfCounters, string perfPrefix) { using (TimedLock.Lock(this)) { string key; string[] accounts; string[] fields; if (IsOpen) { throw new AuthenticationException("Authentication extension is already open."); } perf = new Perf(perfCounters, perfPrefix); maxCacheTime = args.Get("MaxCacheTime", TimeSpan.FromMinutes(5)); key = args.Get("Key", (string)null); if (key == null) { throw new AuthenticationException("Authentication extension argument [{0}] not found."); } accounts = Config.Global.GetArray(key); if (accounts == null) { accounts = new string[0]; } credentials = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase); for (int i = 0; i < accounts.Length; i++) { fields = accounts[i].Split(new char[] { ';' }, StringSplitOptions.None); if (fields.Length != 3) { throw new AuthenticationException("Invalid account credentials in setting [{0}[{1}]].", key, i); } key = fields[0].Trim() + ":" + fields[1].Trim(); if (!credentials.ContainsKey(key)) { credentials.Add(key, fields[2].Trim()); } } } }
/// <summary> /// Handles the performance counter installation if they don't /// already exist. /// </summary> /// <returns>The application's <see cref="PerfCounterSet" />.</returns> public static PerfCounterSet InstallPerfCounters() { bool exists = PerformanceCounterCategory.Exists(Const.AuthServicePerf); PerfCounterSet perfCounters; perfCounters = new PerfCounterSet(false, true, Const.AuthServicePerf, Const.AuthServiceName); if (!exists) { AuthServiceHandler.InstallPerfCounters(perfCounters, null); AuthenticationEngine.InstallPerfCounters(perfCounters, null); perfCounters.Install(); } return(perfCounters); }
/// <summary> /// Installs the service's performance counters by adding them to the /// performance counter set passed. /// </summary> /// <param name="perfCounters">The application's performance counter set (or <c>null</c>).</param> /// <param name="perfPrefix">The string to prefix any performance counter names (or <c>null</c>).</param> public static void Install(PerfCounterSet perfCounters, string perfPrefix) { if (perfCounters == null) { return; } if (perfPrefix == null) { perfPrefix = string.Empty; } perfCounters.Add(new PerfCounter(perfPrefix + IPGeocode_Name, "IP Geocode queries/sec", PerformanceCounterType.RateOfCountsPerSecond32)); perfCounters.Add(new PerfCounter(perfPrefix + FixesReceived_Name, "Location fixes received/sec", PerformanceCounterType.RateOfCountsPerSecond32)); perfCounters.Add(new PerfCounter(perfPrefix + FixesArchived_Name, "Location fixes received/sec", PerformanceCounterType.RateOfCountsPerSecond32)); perfCounters.Add(new PerfCounter(perfPrefix + Runtime_Name, "Service runtime in minutes", PerformanceCounterType.NumberOfItems32)); perfCounters.Add(new PerfCounter(perfPrefix + Entities_Name, "Number of entities tracked", PerformanceCounterType.NumberOfItems32)); perfCounters.Add(new PerfCounter(perfPrefix + Groups_Name, "Number of groups tracked", PerformanceCounterType.NumberOfItems32)); }
/// <summary> /// Initializes the service's performance counters. /// </summary> public static void Initialize() { var perfCounters = new PerfCounterSet(false, true, SwitchConst.NeonSwitchPerf, SwitchConst.NeonSwitchName); Install(perfCounters); if (perfCounters != null) { Runtime = perfCounters[Runtime_Name]; TotalCalls = perfCounters[TotalCalls_Name]; TotalCallRate = perfCounters[TotalCallRate_Name]; } else { Runtime = TotalCalls = TotalCallRate = PerfCounter.Stub; } }
public void PerfCounterSet_Related_Instance() { PerfCounterSet counters = new PerfCounterSet(true, true, "Test_Related_Instance", "Test Help"); PerfCounter A1, B1, C1; PerfCounter A2, B2, C2; try { counters.Add(new PerfCounter("A", "A Help", PerformanceCounterType.NumberOfItems32)); counters.Add(new PerfCounter("B", "B Help", PerformanceCounterType.NumberOfItems32)); counters.Add(new PerfCounter("C", "C Help", PerformanceCounterType.NumberOfItems32)); counters.Relate("A", "C"); counters.Relate("B", "C"); counters.Install(); A1 = counters["A", "1"]; B1 = counters["B", "1"]; C1 = counters["C", "1"]; A2 = counters["A", "2"]; B2 = counters["B", "2"]; C2 = counters["C", "2"]; Assert.AreEqual(0, C1.RawValue); A1.Increment(); Assert.AreEqual(1, C1.RawValue); B1.IncrementBy(5); Assert.AreEqual(6, C1.RawValue); A1.Decrement(); Assert.AreEqual(5, C1.RawValue); Assert.AreEqual(0, C2.RawValue); A2.IncrementBy(100); Assert.AreEqual(100, C2.RawValue); B2.IncrementBy(100); Assert.AreEqual(200, C2.RawValue); } finally { counters.Uninstall(); } }
public PerfCounter Exceptions; // Exceptions/sec /// <summary> /// Initializes the service's performance counters from the performance /// counter set passed. /// </summary> /// <param name="perfCounters">The application's performance counter set (or <c>null</c>).</param> /// <param name="perfPrefix">The string to prefix any performance counter names (or <c>null</c>).</param> public Perf(PerfCounterSet perfCounters, string perfPrefix) { Install(perfCounters, perfPrefix); if (perfPrefix == null) { perfPrefix = string.Empty; } if (perfCounters != null) { Queries = perfCounters[perfPrefix + Queries_Name]; Exceptions = perfCounters[perfPrefix + Exceptions_Name]; } else { Queries = Exceptions = PerfCounter.Stub; } }
/// <summary> /// Establishes a session with the authentication extension. /// </summary> /// <param name="args">The extension specific arguments (see the remarks).</param> /// <param name="query">Ignored for this extension.</param> /// <param name="perfCounters">The application's performance counter set (or <c>null</c>).</param> /// <param name="perfPrefix">The string to prefix any performance counter names (or <c>null</c>).</param> /// <remarks> /// <para> /// This extension recognises the following arguments: /// </para> /// <list type="table"> /// <item> /// <term>Path</term> /// <description> /// The fully qualified path to the credential file. This argument is required. /// </description> /// </item> /// <item> /// <term>Reload</term> /// <description> /// Indicates whether the credentials file should be reloaded before every authentication /// attempt. This can have values such as "yes"/"no" or "true"/"false". This argument /// defaults to "true". /// </description> /// </item> /// <item> /// <term>MaxCacheTime</term> /// <description> /// Specifies the maximum time clients should retain authentication information. /// This is expressed in the same format as timespans parsed by <see cref="Config.Parse(string,TimeSpan)" />. /// This argument defaults to "5m". /// </description> /// </item> /// <item> /// <term>LockoutCount</term> /// <description> /// Specifies the limiting failed authentication count. Accounts /// will be locked when the fail count reaches this number. /// </description> /// </item> /// <item> /// <term>LockoutThreshold</term> /// <description> /// The period of time that can elapse between failed authentication /// attempts where the failed attempts will <b>not</b> be counted against the /// <b>LockoutCount</b>. Set this to <see cref="TimeSpan.Zero" /> /// to disable account lockout for the realm. /// </description> /// </item> /// <item> /// <term>LockoutTime</term> /// <description> /// The period of time an account will remain locked after being locked /// out due to too many failed authentication attempts. /// </description> /// </item> /// </list> /// <note> /// All calls to <see cref="Open" /> must be matched with a call /// to <see cref="Close" /> or <see cref="Dispose" />. /// </note> /// </remarks> public void Open(ArgCollection args, string query, PerfCounterSet perfCounters, string perfPrefix) { using (TimedLock.Lock(this)) { if (IsOpen) { throw new AuthenticationException("Authentication extension is already open."); } perf = new Perf(perfCounters, perfPrefix); path = EnvironmentVars.Expand(args["Path"]); reload = args.Get("Reload", true); maxCacheTime = args.Get("MaxCacheTime", TimeSpan.FromMinutes(5)); if (!reload) { credentials = LoadCredentials(); } } }
/// <summary> /// Establishes a session with the authentication extension. /// </summary> /// <param name="args">The extension specific arguments (see the remarks).</param> /// <param name="query">The database query template (see the remarks).</param> /// <param name="perfCounters">The application's performance counter set (or <c>null</c>).</param> /// <param name="perfPrefix">The string to prefix any performance counter names (or <c>null</c>).</param> /// <remarks> /// <para> /// This extension recognises the following arguments: /// </para> /// <list type="table"> /// <item> /// <term>Connection String</term> /// <description> /// All of the arguments that are not explicitly described below will be /// collected together as the ODBC connection string. /// </description> /// </item> /// <item> /// <term>MaxCacheTime</term> /// <description> /// Specifies the maximum time clients should retain authentication information. /// This is expressed in the same format as timespans parsed by <see cref="Config.Parse(string,TimeSpan)" />. /// This argument defaults to "5m". /// </description> /// </item> /// <item> /// <term>LockoutCount</term> /// <description> /// Specifies the limiting failed authentication count. Accounts /// will be locked when the fail count reaches this number. /// </description> /// </item> /// <item> /// <term>LockoutThreshold</term> /// <description> /// The period of time that can elapse between failed authentication /// attempts where the failed attempts will <b>not</b> be counted against the /// <b>LockoutCount</b>. Set this to <see cref="TimeSpan.Zero" /> /// to disable account lockout for the realm. /// </description> /// </item> /// <item> /// <term>LockoutTime</term> /// <description> /// The period of time an account will remain locked after being locked /// out due to too many failed authentication attempts. /// </description> /// </item> /// </list> /// <note> /// All calls to <see cref="Open" /> must be matched with a call /// to <see cref="Close" /> or <see cref="Dispose" />. /// </note> /// </remarks> public void Open(ArgCollection args, string query, PerfCounterSet perfCounters, string perfPrefix) { var sb = new StringBuilder(128); using (TimedLock.Lock(this)) { if (IsOpen) { throw new AuthenticationException("Authentication extension is already open."); } perf = new Perf(perfCounters, perfPrefix); queryTemplate = query; // Process the built-in arguments maxCacheTime = args.Get("MaxCacheTime", TimeSpan.FromMinutes(5)); // Build the connection string foreach (string key in args) { switch (key.ToLowerInvariant()) { case "maxcachetime": case "LockoutCount": case "LockoutThreshold": case "LockoutTime": break; // Ignore the built-in arguments. default: sb.AppendFormat("{0}={1};", key, args[key]); break; } } conString = sb.ToString(); } }
public PerfCounter Runtime; // Service runtime in minutes /// <summary> /// Initializes the service's performance counters from the performance /// counter set passed. /// </summary> /// <param name="perfCounters">The application's performance counter set (or <c>null</c>).</param> /// <param name="perfPrefix">The string to prefix any performance counter names (or <c>null</c>).</param> public Perf(PerfCounterSet perfCounters, string perfPrefix) { Install(perfCounters, perfPrefix); if (perfPrefix == null) { perfPrefix = string.Empty; } if (perfCounters != null) { IsMaster = perfCounters[perfPrefix + IsMaster_Name]; AdminMessageRate = perfCounters[perfPrefix + AdminMessageRate_Name]; AdminByteRate = perfCounters[perfPrefix + AdminByteRate_Name]; BroadcastReceiveMessageRate = perfCounters[perfPrefix + BroadcastReceiveMessageRate_Name]; BroadcastReceiveByteRate = perfCounters[perfPrefix + BroadcastReceiveByteRate_Name]; BroadcastSendMessageRate = perfCounters[perfPrefix + BroadcastSendMessageRate_Name]; BroadcastSendByteRate = perfCounters[perfPrefix + BroadcastSendByteRate_Name]; TotalMessageRate = perfCounters[perfPrefix + TotalMessageRate_Name]; TotalByteRate = perfCounters[perfPrefix + TotalByteRate_Name]; ServerCount = perfCounters[perfPrefix + ServerCount_Name]; ClientCount = perfCounters[perfPrefix + ClientCount_Name]; Runtime = perfCounters[perfPrefix + Runtime_Name]; } else { IsMaster = AdminMessageRate = AdminByteRate = BroadcastReceiveMessageRate = BroadcastReceiveByteRate = BroadcastSendMessageRate = BroadcastSendByteRate = TotalMessageRate = TotalByteRate = ServerCount = ClientCount = Runtime = PerfCounter.Stub; } }
public PerfCounter Runtime; // Service runtime in minutes /// <summary> /// Initializes the service's performance counters from the performance /// counter set passed. /// </summary> /// <param name="perfCounters">The application's performance counter set (or <c>null</c>).</param> /// <param name="perfPrefix">The string to prefix any performance counter names (or <c>null</c>).</param> public Perf(PerfCounterSet perfCounters, string perfPrefix) { Install(perfCounters, perfPrefix); if (perfPrefix == null) { perfPrefix = string.Empty; } if (perfCounters != null) { Queries = perfCounters[perfPrefix + Queries_Name]; Status = perfCounters[perfPrefix + Status_Name]; Runtime = perfCounters[perfPrefix + Runtime_Name]; } else { Queries = Status = Runtime = PerfCounter.Stub; } }
public PerfCounter Runtime; // Service runtime in minutes /// <summary> /// Initializes the service's performance counters from the performance /// counter set passed. /// </summary> /// <param name="perfCounters">The application's performance counter set (or <c>null</c>).</param> /// <param name="perfPrefix">The string to prefix any performance counter names (or <c>null</c>).</param> public Perf(PerfCounterSet perfCounters, string perfPrefix) { Install(perfCounters, perfPrefix); if (perfPrefix == null) { perfPrefix = string.Empty; } if (perfCounters != null) { Uploads = perfCounters[perfPrefix + Uploads_Name]; Deliveries = perfCounters[perfPrefix + Deliveries_Name]; CacheLoads = perfCounters[perfPrefix + CacheLoads_Name]; Runtime = perfCounters[perfPrefix + Runtime_Name]; } else { Uploads = Deliveries = CacheLoads = Runtime = PerfCounter.Stub; } }