Ntp.Analyzer.Process.Initializer Class Reference

Collaboration diagram for Ntp.Analyzer.Process.Initializer:

Public Member Functions
	Initializer (string configFile, int pid, string pidFile, string name, LogGroup initlog)
	Initializes a new instance of the Initializer class. More...
void	Run ()
	Run the NTP Analyzer. More...

Properties
SignalHandler	Controller [get, private set]
List< Listener >	Listeners [get]
LogBase	Log [get, private set]
List< IRequest >	Nodes [get]
bool	Ready [get, private set]
Scheduler	Scheduler [get, private set]

Private Member Functions
void	InitializeApplication ()
	Initializes the application and database state. More...
void	InitializeCluster ()
	Initializes the cluster nodes. More...
bool	InitializeConfiguration ()
	Initializes the configuration. More...
void	InitializeData ()
bool	InitializeDatabase ()
void	InitializeListeners ()
	Initializes the listeners. More...
bool	InitializeLog ()
	Initializes the log. More...
void	InitializeScheduler ()
	Initializes the scheduler. More...
bool	InitializeSecurity ()
	Initializes the security settings. More...

Private Attributes
Configuration	config
readonly string	configFile
readonly LogGroup	initlog
readonly string	name
readonly int	pid
readonly string	pidFile
readonly string	version

Static Private Attributes
static bool	firstrun = true

Detailed Description

Definition at line 50 of file Initializer.cs.

Constructor & Destructor Documentation

Ntp.Analyzer.Process.Initializer.Initializer ( string  configFile, int  pid, string  pidFile, string  name, LogGroup  initlog  )

inline

Initializes a new instance of the Initializer class.

Parameters

configFile	Config file to use.
pid	Process ID.
pidFile	Where to write Process ID file.
name	Name of process ID. Used when shutting down.
initlog	Log used during initialization.

Definition at line 60 of file Initializer.cs.

References version.

        {
            this.configFile = configFile;
            this.pid = pid;
            this.pidFile = pidFile;
            this.name = name;
            this.initlog = initlog;
            Nodes = new List<IRequest>();
            Listeners = new List<Listener>();
            version = "0.8.2";
        }

Member Function Documentation

void Ntp.Analyzer.Process.Initializer.InitializeApplication ( )

inlineprivate

Initializes the application and database state.

Definition at line 128 of file Initializer.cs.

References Ntp.Analyzer.Monitor.Server.ApplicationState.Config, Ntp.Analyzer.Monitor.Server.ApplicationState.ConfigFile, Ntp.Analyzer.Config.Node.Configuration.Heartbeat, Ntp.Analyzer.Monitor.Server.ApplicationState.Log, Ntp.Analyzer.Monitor.Server.ApplicationState.Name, Ntp.Analyzer.Monitor.Server.ApplicationState.Pid, Ntp.Analyzer.Config.Node.HeartbeatConfiguration.Rate, version, and Ntp.Analyzer.Monitor.Server.ApplicationState.Version.

        {
            // Start signal controller
            Controller = new SignalHandler(name, initlog);
            Controller.Start();

            // Initialize application state
            ApplicationState.Version = version;
            ApplicationState.Pid = pid;
            ApplicationState.Name = name;
            ApplicationState.Config = config;
            ApplicationState.ConfigFile = configFile;
            ApplicationState.Log = Log;

            if (config.Heartbeat == null)
                return;

            var beat = new Heartbeat(Log, config.Heartbeat.Rate);
            beat.Start();
        }

void Ntp.Analyzer.Process.Initializer.InitializeCluster ( )

inlineprivate

Initializes the cluster nodes.

Definition at line 152 of file Initializer.cs.

References Ntp.Analyzer.Config.Node.Configuration.Cluster, e, and Ntp.Analyzer.Config.Node.ClusterConfiguration.Nodes.

        {
            if (config.Cluster == null)
                return;

            try
            {
                foreach (var node in config.Cluster.Nodes)
                {
                    var ip = IPAddress.Parse(node.Ip);
                    var req = new TextRequest(ip, node.Port);
                    Nodes.Add(req);
                    Log.ClusterReady(node);
                }
            }
            catch (Exception e)
            {
                initlog.ClusterError(e);
            }
        }

bool Ntp.Analyzer.Process.Initializer.InitializeConfiguration ( )

inlineprivate

Initializes the configuration.

Definition at line 176 of file Initializer.cs.

References Ntp.Common.Log.File.

        {
            if (!File.Exists(configFile))
            {
                initlog.NoConfig(configFile);
                return false;
            }

            var builder = new ConfigBuilder(configFile);
            config = builder.Execute();

            if (!builder.Errors.Any() && config != null)
                return true;

            initlog.AddErrors(builder.Errors);
            return false;
        }

void Ntp.Analyzer.Process.Initializer.InitializeData ( )

inlineprivate

Definition at line 194 of file Initializer.cs.

References Ntp.Analyzer.Data.DataFace.AssociationEntries, Ntp.Analyzer.Import.ImportFactory.CreatePeerImporter(), Ntp.Analyzer.Config.Node.Configuration.Database, e, Ntp.Analyzer.Data.DataFace.Hosts, Ntp.Analyzer.Config.Node.DatabaseConfiguration.Import, Ntp.Analyzer.Data.Import.TimeServerWebAdapter.Initialize(), Ntp.Analyzer.Config.Node.DatabaseConfiguration.Initialize, Ntp.Analyzer.Data.DataFace.Instance, Ntp.Analyzer.Data.Import.TimeServers.List, Ntp.Analyzer.Data.DataFace.Peers, Ntp.Analyzer.Data.DataFace.Servers, and Ntp.Analyzer.Config.Node.Configuration.Servers.

        {
            if (!config.Database.Initialize)
                return;

            TimeServerWebAdapter.Initialize(config.Database.Import);

            try
            {
                // Initialize hosts
                foreach (var server in config.Servers)
                {
                    var host = DataFace.Instance.Hosts.SingleOrDefault(h => h.Id == server.HostId);
                    if (host == null)
                    {
                        IPAddress ip;
                        try
                        {
                            ip = Dns.GetHostAddresses(server.ServerName)[0];
                        }
                        catch
                        {
                            ip = IPAddress.None;
                        }

                        int? orgId = null;
                        if (TimeServers.List.ContainsKey(server.ServerName))
                        {
                            orgId = TimeServers.List[server.ServerName];
                            Log.KnownServer(orgId.Value, server.ServerName);
                        }
                        else if (!Equals(ip, IPAddress.None) && TimeServers.List.ContainsKey(ip.ToString()))
                        {
                            orgId = TimeServers.List[ip.ToString()];
                            Log.KnownServer(orgId.Value, ip.ToString());
                        }

                        host = new Host(server.HostId, server.ServerName, ip.ToString(), orgId);
                        DataFace.Instance.Hosts.Save(host);
                        Log.NewHost(server, ip);
                    }
                    else if (host.OrgId == null && TimeServers.List.ContainsKey(host.Ip))
                    {
                        host.OrgId = TimeServers.List[host.Ip];
                        Log.KnownServer(host.OrgId.Value, host.Ip);
                        DataFace.Instance.Hosts.Save(host);
                    }
                    else if (host.OrgId == null && TimeServers.List.ContainsKey(host.Name))
                    {
                        host.OrgId = TimeServers.List[host.Name];
                        Log.KnownServer(host.OrgId.Value, host.Name);
                        DataFace.Instance.Hosts.Save(host);
                    }

                    // Flush old association entries
                    DataFace.Instance.AssociationEntries.Delete(server.HostId);

                    // Initialize peers
                    var peerImporter = ImportFactory.CreatePeerImporter(server.ServerName, server.ServerType, host, Log);

                    foreach (var entry in peerImporter.ToList())
                    {
                        var currentEntry = entry;
                        var peerList = DataFace.Instance.Peers.Where(p => p.Ip == currentEntry.Remote).ToList();

                        if (!peerList.Any())
                        {
                            // Create new peer in database
                            TimeServer timeServer = null;
                            if (TimeServers.List.ContainsKey(entry.Remote))
                            {
                                int orgId = TimeServers.List[entry.Remote];
                                timeServer = DataFace.Instance.Servers[orgId];
                                Log.KnownServer(orgId, entry.Remote);
                            }

                            var hostName = entry.Remote;

                            try
                            {
                                var hostEntry = Dns.GetHostEntry(entry.Remote);
                                hostName = hostEntry.HostName;
                            }
                            catch (Exception e)
                            {
                                Log.HostNameNotFound(entry.Remote, e);
                            }

                            var peer = new Peer(hostName, entry.Remote, timeServer);
                            DataFace.Instance.Peers.Save(peer);
                            Log.NewPeer(entry);
                        }
                        else if (TimeServers.List.ContainsKey(entry.Remote))
                        {
                            // Try to update existing peer
                            var peer = peerList.First();
                            if (peer.Server != null && peer.Server.IsOrgServer)
                                continue;

                            int orgId = TimeServers.List[entry.Remote];
                            var timeServer = DataFace.Instance.Servers[orgId];
                            Log.KnownServer(orgId, entry.Remote);
                            if (timeServer == null)
                                continue;

                            peer.Server = timeServer;
                            DataFace.Instance.Peers.Save(peer);
                        }
                    }
                }
            }
            catch (Exception e)
            {
                Log.TableError(e);
            }
        }

Here is the call graph for this function:

bool Ntp.Analyzer.Process.Initializer.InitializeDatabase ( )

inlineprivate

Definition at line 311 of file Initializer.cs.

References Ntp.Analyzer.Config.Node.Configuration.Database, e, Ntp.Data.Provider.SqlDatabaseFactory.Initialize(), Ntp.Analyzer.Config.Node.DatabaseConfiguration.Initialize, Ntp.Analyzer.Data.DataFace.Initialize(), Ntp.Data.Provider.SqlDatabaseFactory.Instance, and Ntp.Analyzer.Config.Node.DatabaseConfiguration.Upgrade.

        {
            SqlDatabaseFactory.Initialize(config.Database);
            DataFace.Initialize(Log);

            var checker = new SqlDatabaseChecker(SqlDatabaseFactory.Instance, Controller, initlog);
            checker.CheckConnection();

            if (Controller.Stopped)
                return false;

            try
            {
                var initializer = new DatabaseInitializer(
                    config.Database.Initialize,
                    config.Database.Upgrade,
                    Log);

                return initializer.Execute();
            }
            catch (Exception e)
            {
                initlog.DatabaseError(e);
            }

            return false;
        }

Here is the call graph for this function:

void Ntp.Analyzer.Process.Initializer.InitializeListeners ( )

inlineprivate

Initializes the listeners.

Definition at line 342 of file Initializer.cs.

References e, and Ntp.Analyzer.Config.Node.Configuration.Monitors.

        {
            try
            {
                foreach (var monitor in config.Monitors)
                {
                    var listener = new Listener(monitor.Ip, monitor.Port, Log);
                    listener.Open();
                    Listeners.Add(listener);
                    initlog.ListenerReady(listener);
                }
            }
            catch (Exception e)
            {
                initlog.ListenerError(e);
            }
        }

bool Ntp.Analyzer.Process.Initializer.InitializeLog ( )

inlineprivate

Initializes the log.

Definition at line 363 of file Initializer.cs.

References Ntp.Analyzer.Config.Node.PermissionConfiguration.AppUserId, Ntp.Common.Log.LogFactory.CreateLog(), e, Ntp.Common.Log.LogBase.Initialize(), Ntp.Analyzer.Config.Node.Configuration.Log, Ntp.Analyzer.Config.Node.Configuration.Permission, and Ntp.Common.IO.Permission.SetUserId().

        {
            try
            {
                Log = LogFactory.CreateLog(config.Log);
                Log.Initialize();
            }
            catch (Exception e)
            {
                initlog.InitializationError(e);
                return false;
            }

            initlog.Add(Log);

            if (firstrun)
                initlog.Starting(version);

            initlog.ConfigFile(configFile);
            initlog.ProcessId(pid);
            initlog.InstanceName(name);

            if (config.Permission?.AppUserId == null)
                return true;

            if (Permission.SetUserId(config.Permission.AppUserId.Value))
                initlog.UserId(config.Permission.AppUserId.Value);

            return true;
        }

Here is the call graph for this function:

void Ntp.Analyzer.Process.Initializer.InitializeScheduler ( )

inlineprivate

Initializes the scheduler.

Definition at line 397 of file Initializer.cs.

References Ntp.Common.Process.Scheduler.Add(), Ntp.Analyzer.Config.Node.Configuration.Bulks, e, Ntp.Common.Process.Scheduler.Log, Ntp.Analyzer.Config.Node.Configuration.Notify, Ntp.Common.Process.Job.Reset(), Ntp.Analyzer.Monitor.Server.ApplicationState.Scheduler, Ntp.Analyzer.Config.Node.Configuration.Servers, Ntp.Common.Process.Scheduler.StartTime, and Ntp.Analyzer.Monitor.Server.ApplicationState.StartupTime.

        {
            Job.Reset();

            try
            {
                Scheduler = new Scheduler(Log);
                Log.JobInitStart();

                foreach (var bulk in config.Bulks)
                    Scheduler.Add(new BulkStatJob(bulk, Scheduler.Log));

                // Add jobs to schedule.
                foreach (var server in config.Servers)
                {
                    Scheduler.Add(new HostStatJob(server.HostStats, Scheduler.Log));
                    Scheduler.Add(new HostIoStatJob(server.HostIoStats, Scheduler.Log));
                    Scheduler.Add(new PeerStatJob(server.PeerStats, Scheduler.Log));
                    Scheduler.Add(new DriftStatJob(server.DriftStats, Scheduler.Log));
                    Scheduler.Add(new AboutPageJob(server.Menu, server.AboutPage, Scheduler.Log));

                    foreach (var peerPage in server.PeerPages)
                        Scheduler.Add(new PeerPageJob(server.Menu, peerPage, Scheduler.Log));

                    foreach (var hostPage in server.HostPages)
                        Scheduler.Add(new HostPageJob(server.Menu, hostPage, Scheduler.Log));

                    foreach (var hostGraph in server.HostGraphs)
                        Scheduler.Add(new HostGraphJob(hostGraph, Scheduler.Log));

                    foreach (var trafficGraph in server.TrafficGraphs)
                        Scheduler.Add(new TrafficGraphJob(trafficGraph, Scheduler.Log));

                    foreach (var peerGraph in server.PeerGraphs)
                        Scheduler.Add(new PeerGraphJob(peerGraph, Scheduler.Log));

                    foreach (var peerSummaryPage in server.PeerSummaryPages)
                        Scheduler.Add(new PeerSummaryJob(server.Menu, peerSummaryPage, Scheduler.Log));

                    Scheduler.Add(new HostGraphPageJob(server.HostGraphPage, Scheduler.Log));
                    Scheduler.Add(new PeerGraphPageJob(server.PeerGraphPage, Scheduler.Log));
                }

                // Add the surveillance/notify job.
                if (config.Notify != null)
                {
                    var adminJob = new NotifyJob(config.Notify, Log, pid, configFile);
                    Scheduler.Add(adminJob);
                    adminJob.SetJobList(Scheduler);
                }

                Log.JobInitEnd();
            }
            catch (Exception e)
            {
                initlog.SchedulerError(e);
            }

            ApplicationState.Scheduler = Scheduler;
            ApplicationState.StartupTime = Scheduler.StartTime;
        }

Here is the call graph for this function:

bool Ntp.Analyzer.Process.Initializer.InitializeSecurity ( )

inlineprivate

Initializes the security settings.

Definition at line 462 of file Initializer.cs.

References Ntp.Analyzer.Config.Node.PermissionConfiguration.AppUserId, e, Ntp.Common.Log.File, Ntp.Analyzer.Export.FileSystemDestination.FileGroupId, Ntp.Analyzer.Export.FileSystemDestination.FileMask, Ntp.Analyzer.Config.Node.PermissionConfiguration.FileMode, Ntp.Analyzer.Export.FileSystemDestination.FileUserId, Ntp.Analyzer.Config.Node.PermissionConfiguration.GroupId, Ntp.Analyzer.Config.Node.Configuration.Permission, Ntp.Common.IO.Permission.SetUserId(), and Ntp.Analyzer.Config.Node.PermissionConfiguration.UserId.

        {
            // Drop privileges
            if (config.Permission?.AppUserId != null)
            {
                if (!Permission.SetUserId(config.Permission.AppUserId.Value))
                {
                    initlog.UserIdError(config.Permission.AppUserId.Value);
                }
            }

            // Create pid file
            if (pidFile != null)
            {
                try
                {
                    File.WriteAllText(pidFile, pid.ToString(CultureInfo.InvariantCulture));
                }
                catch (Exception e)
                {
                    initlog.PidFileError(e);
                    return false;
                }
            }

            // Set permissions
            if (config.Permission == null)
                return true;

            FileSystemDestination.FileMask = config.Permission.FileMode;
            FileSystemDestination.FileUserId = config.Permission?.UserId;
            FileSystemDestination.FileGroupId = config.Permission?.GroupId;

            return true;
        }

Here is the call graph for this function:

void Ntp.Analyzer.Process.Initializer.Run ( )

inline

Run the NTP Analyzer.

Definition at line 96 of file Initializer.cs.

        {
            // Neutralize.
            Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;

            bool proceed = InitializeConfiguration();

            if (proceed)
                proceed = InitializeSecurity();

            if (proceed)
                proceed = InitializeLog();

            if (proceed)
            {
                InitializeApplication();
                InitializeListeners();
                InitializeCluster();
                InitializeScheduler();
                proceed = InitializeDatabase();
            }

            if (proceed)
                InitializeData();

            Ready = proceed;
            firstrun = false;
        }

Member Data Documentation

Configuration Ntp.Analyzer.Process.Initializer.config

private

Definition at line 79 of file Initializer.cs.

readonly string Ntp.Analyzer.Process.Initializer.configFile

private

Definition at line 73 of file Initializer.cs.

bool Ntp.Analyzer.Process.Initializer.firstrun = true

staticprivate

Definition at line 72 of file Initializer.cs.

readonly LogGroup Ntp.Analyzer.Process.Initializer.initlog

private

Definition at line 74 of file Initializer.cs.

readonly string Ntp.Analyzer.Process.Initializer.name

private

Definition at line 75 of file Initializer.cs.

readonly int Ntp.Analyzer.Process.Initializer.pid

private

Definition at line 76 of file Initializer.cs.

readonly string Ntp.Analyzer.Process.Initializer.pidFile

private

Definition at line 77 of file Initializer.cs.

readonly string Ntp.Analyzer.Process.Initializer.version

private

Definition at line 78 of file Initializer.cs.

Property Documentation

SignalHandler Ntp.Analyzer.Process.Initializer.Controller

getprivate set

Definition at line 81 of file Initializer.cs.

List<Listener> Ntp.Analyzer.Process.Initializer.Listeners

get

Definition at line 89 of file Initializer.cs.

LogBase Ntp.Analyzer.Process.Initializer.Log

getprivate set

Definition at line 85 of file Initializer.cs.

List<IRequest> Ntp.Analyzer.Process.Initializer.Nodes

get

Definition at line 87 of file Initializer.cs.

bool Ntp.Analyzer.Process.Initializer.Ready

getprivate set

Definition at line 91 of file Initializer.cs.

Scheduler Ntp.Analyzer.Process.Initializer.Scheduler

getprivate set

Definition at line 83 of file Initializer.cs.

---

The documentation for this class was generated from the following file:

• Ntp.Analyzer.Process/Initializer.cs