instrumental_tools 1.0.0 → 1.1.3

data/win32/src/instrumental/InstrumentServerProcess.cs

@@ -0,0 +1,147 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+
+
+
+namespace Instrumental
+{
+
+  class InstrumentServerProcess
+  {
+
+    private EventLog destination;
+    private Process  process;
+
+    public InstrumentServerProcess(EventLog log){
+      destination = log;
+    }
+
+    public void Run(string executablePath, string configPath, string hostname, bool scriptsEnabled, string scriptsDirectory){
+      SetupProcess(executablePath, configPath, hostname, scriptsEnabled, scriptsDirectory);
+    }
+
+    public bool IsRunning(){
+      if(process == null){
+        return false;
+      }
+      try {
+        return !Convert.ToBoolean(process?.HasExited);
+      } catch(InvalidOperationException){
+        return false;
+      }
+    }
+
+    public void CleanupProcess(){
+      if(IsRunning()){
+        process.Kill();
+        process.WaitForExit();
+      }
+      process?.Close();
+      process = null;
+    }
+
+    public TimeSpan Age(){
+      DateTime lastStarted = process?.StartTime ?? DateTime.Now;
+      return DateTime.Now - lastStarted;
+    }
+
+    public string RubyDir(string basePath){
+      return basePath + "\\lib\\ruby";
+    }
+
+    public string RubyLibDir(string basePath){
+      return RubyDir(basePath) + "\\lib\\ruby";
+    }
+
+    public string AppDir(string basePath){
+      return basePath + "\\lib\\app";
+    }
+
+    public string VendorDir(string basePath){
+      return basePath + "\\lib\\vendor";
+    }
+
+    public string Gemfile(string basePath){
+      return VendorDir(basePath) + "\\Gemfile";
+    }
+
+    public string RubyExecutable(string basePath){
+      return RubyDir(basePath) + "\\bin.real\\ruby.exe";
+    }
+
+    public string InstrumentServerScript(string basePath){
+      return AppDir(basePath) + "\\bin\\instrument_server";
+    }
+
+    public string RubyFlags(){
+      return "-rbundler/setup";
+    }
+
+    public string SslCertFile(string basePath){
+      return RubyDir(basePath) + "\\lib\\ca-bundle.crt";
+    }
+
+    public void SetupProcess(string executablePath, string configPath, string hostname, bool scriptsEnabled, string scriptsDirectory){
+      CleanupProcess();
+      string args                              = $"{RubyFlags()} \"{InstrumentServerScript(executablePath)}\" -f \"{configPath}\" -H \"{hostname}\"";
+      if(scriptsEnabled){
+        args += $" -e -s \"{scriptsDirectory}\"";
+      }
+      args += " foreground";
+
+      string rubyVersion = "2.1.0";
+      string rubyArch = "i386-mingw32";
+      string rubyDir = RubyLibDir(executablePath);
+      string[] libDirs = new string[]{
+        $"{rubyDir}\\site_ruby\\{rubyVersion}",
+        $"{rubyDir}\\site_ruby\\{rubyVersion}\\{rubyArch}",
+        $"{rubyDir}\\site_ruby",
+        $"{rubyDir}\\vendor_ruby\\{rubyVersion}",
+        $"{rubyDir}\\vendor_ruby\\{rubyVersion}\\{rubyArch}",
+        $"{rubyDir}\\vendor_ruby",
+        $"{rubyDir}\\{rubyVersion}",
+        $"{rubyDir}\\{rubyVersion}\\{rubyArch}"
+      };
+
+      Dictionary<string, string> env = new Dictionary<string, string>(){
+        { "BUNDLE_GEMFILE",       Gemfile(executablePath) },
+        { "RUBYLIB",              String.Join(";", libDirs) },
+        { "SSL_CERT_FILE",        SslCertFile(executablePath) }
+      };
+
+      destination.WriteEntry($"Trying to start {RubyExecutable(executablePath)} {args} with env {String.Join(";", env)}", EventLogEntryType.Information);
+
+      process                                  = new Process();
+      process.StartInfo.FileName               = RubyExecutable(executablePath);
+      process.StartInfo.Arguments              = args;
+
+      foreach(KeyValuePair<string, string> entry in env){
+        process.StartInfo.EnvironmentVariables[entry.Key] = entry.Value;
+      }
+
+      process.StartInfo.UseShellExecute        = false;
+      process.StartInfo.RedirectStandardOutput = true;
+      process.StartInfo.RedirectStandardError  = true;
+      process.StartInfo.CreateNoWindow         = true;
+      process.OutputDataReceived              += new DataReceivedEventHandler((sender, e) => {
+          if(!String.IsNullOrEmpty(e.Data)){
+            destination.WriteEntry(e.Data, EventLogEntryType.Information);
+          }
+        });
+      process.ErrorDataReceived               += new DataReceivedEventHandler((sender, e) => {
+          if(!String.IsNullOrEmpty(e.Data)){
+            destination.WriteEntry(e.Data, EventLogEntryType.Error);
+          }
+        });
+      if(!process.Start()){
+        destination.WriteEntry("Failed to start process", EventLogEntryType.Error);
+      } else {
+        process.BeginOutputReadLine();
+        process.BeginErrorReadLine();
+      }
+    }
+
+
+  }
+}

data/win32/src/instrumental/InstrumentServerProcessWorker.cs

@@ -0,0 +1,89 @@
+using System;
+using System.Diagnostics;
+using System.Threading;
+
+namespace Instrumental
+{
+
+  class InstrumentServerProcessWorker
+  {
+
+    private volatile bool doRun;
+    private string executablePath;
+    private string configPath;
+    private string hostname;
+    private bool scriptsEnabled;
+    private string scriptsDirectory;
+    private EventLog destination;
+    private Thread runnerThread;
+    private TimeSpan checkInterval;
+    private int retryFallback;
+    private int retries;
+    private int maxFallbackMult;
+
+    public InstrumentServerProcessWorker(EventLog log, string execPath, string confPath, string host, bool enableScripts, string scriptDir){
+      destination      = log;
+      executablePath   = execPath;
+      configPath       = confPath;
+      hostname         = host;
+      scriptsEnabled   = enableScripts;
+      scriptsDirectory = scriptDir;
+      runnerThread     = null;
+      doRun            = false;
+      checkInterval    = TimeSpan.FromSeconds(5);
+      retryFallback    = 7; // Seconds
+      maxFallbackMult  = 3; // Seconds
+      retries          = -1;
+    }
+
+    public void Run(){
+      destination.WriteEntry("Starting worker thread", EventLogEntryType.Information);
+      InstrumentServerProcess process = new InstrumentServerProcess(destination);
+      try {
+        process.Run(executablePath, configPath, hostname, scriptsEnabled, scriptsDirectory);
+      } catch (Exception ex) {
+        destination.WriteEntry("Exception trying to start, " + ex.Message, EventLogEntryType.Error);
+      }
+      DateTime lastIter = DateTime.Now;
+      DateTime lastExec = lastIter;
+      while(doRun){
+        Thread.Sleep(checkInterval);
+        try {
+          if(!process.IsRunning()){
+            if( (DateTime.Now - lastExec) > TimeSpan.FromSeconds(Math.Pow(retryFallback, retries))){
+              destination.WriteEntry("Attempting to start process", EventLogEntryType.Information);
+              process.Run(executablePath, configPath, hostname, scriptsEnabled, scriptsDirectory);
+              lastExec = DateTime.Now;
+              retries = Math.Min(retries + 1, maxFallbackMult);
+            }
+          }
+        } catch (Exception ex) {
+          destination.WriteEntry("Exception trying to start, " + ex.Message, EventLogEntryType.Error);
+          retries = Math.Min(retries + 1, maxFallbackMult);
+        }
+      }
+      process.CleanupProcess();
+      destination.WriteEntry("Worker thread ended", EventLogEntryType.Information);
+    }
+
+    public void RequestStop(){
+      doRun = false;
+    }
+
+    public void Stop(){
+      RequestStop();
+      runnerThread?.Join();
+      runnerThread = null;
+    }
+
+    public void Start(){
+      if(Convert.ToBoolean(runnerThread?.IsAlive)){
+        Stop();
+      }
+      doRun = true;
+      runnerThread = new Thread(this.Run);
+      runnerThread.Start();
+    }
+
+  }
+}

data/win32/src/instrumental/InstrumentServerService.cs

@@ -0,0 +1,146 @@
+using Microsoft.Win32;
+
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Reflection;
+using System.ServiceProcess;
+using System.Threading;
+
+namespace Instrumental
+{
+  class InstrumentServerService : ServiceBase
+  {
+    public const string NameOfService       = "Instrument Server";
+    public const string PathKey             = "Path";
+    public const string ConfigKey           = "Config";
+    public const string HostnameKey         = "Hostname";
+    public const string EnableScriptsKey    = "ScriptsEnabled";
+    public const string ScriptsDirectoryKey = "ScriptsDirectory";
+    public const string InstrumentalKey     = "Instrumental";
+
+    private InstrumentServerProcessWorker ProcessWorker;
+
+    public InstrumentServerService()
+    {
+      this.ServiceName                 = InstrumentServerService.NameOfService;
+
+      this.EventLog.Log                = "Application";
+
+      this.CanHandlePowerEvent         = false;
+      this.CanHandleSessionChangeEvent = false;
+      this.CanPauseAndContinue         = false;
+      this.CanShutdown                 = false;
+      this.CanStop                     = true;
+
+      string path = BasePath() ?? DefaultBasePath();
+      EventLog.WriteEntry($"Starting with path {BasePath()} (Default: {DefaultBasePath()}), config {Config()} (Default: {DefaultConfig()}), hostname {Hostname()} (Default: {DefaultHostname()}), scripts enabled {ScriptsEnabled()}, scripts directory {ScriptsDirectory()} (Default: {DefaultScriptsDirectory()}), values taken from {InstrumentalRegistryKey()}", EventLogEntryType.Information);
+
+      this.ProcessWorker               = new InstrumentServerProcessWorker(EventLog,
+                                                                           path,
+                                                                           Config() ?? DefaultConfig(),
+                                                                           Hostname() ?? DefaultHostname(),
+                                                                           ScriptsEnabled(),
+                                                                           ScriptsDirectory() ?? DefaultScriptsDirectory());
+    }
+
+    static void Main()
+    {
+      ServiceBase.Run(new InstrumentServerService());
+    }
+
+    public static RegistryKey InstrumentalRegistryKey(bool withWriteAccess = false){
+      RegistryKey localKey;
+      if(Environment.Is64BitOperatingSystem){
+        localKey = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry64);
+      } else {
+        localKey = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry32);
+      }
+      if(withWriteAccess){
+        return localKey.OpenSubKey("SOFTWARE", true).CreateSubKey(InstrumentalKey);
+      } else {
+        return localKey.OpenSubKey("SOFTWARE").OpenSubKey(InstrumentalKey);
+      }
+    }
+
+    public static string AssemblyDirectory()
+    {
+      string codeBase     = Assembly.GetExecutingAssembly().CodeBase;
+      UriBuilder uri      = new UriBuilder(codeBase);
+      string assemblyPath = Uri.UnescapeDataString(uri.Path);
+      return Path.GetDirectoryName(assemblyPath);
+    }
+
+    public static string StringFromRegistryKey(string keyName){
+      RegistryKey regkey = InstrumentalRegistryKey();
+      if(regkey != null){
+        return Convert.ToString(regkey.GetValue(keyName));
+      } else {
+        return null;
+      }
+    }
+
+    public static string BasePath() {
+      return StringFromRegistryKey(PathKey);
+    }
+
+    public static string DefaultBasePath() {
+      return InstrumentServerService.AssemblyDirectory();
+    }
+
+    public static string Config() {
+      return StringFromRegistryKey(ConfigKey);
+    }
+
+    public static string DefaultConfig() {
+      return DefaultBasePath() + "\\etc\\instrumental.yml";
+    }
+
+    public static string Hostname(){
+      return StringFromRegistryKey(HostnameKey);
+    }
+
+    public static string DefaultHostname(){
+      return System.Environment.MachineName;
+    }
+
+    public static bool ScriptsEnabled() {
+      object value = InstrumentalRegistryKey()?.GetValue(EnableScriptsKey);
+      if(value != null){
+        return Convert.ToBoolean(value);
+      } else {
+        return DefaultScriptsEnabled();
+      }
+    }
+
+    public static bool DefaultScriptsEnabled(){
+      return false;
+    }
+
+    public static string ScriptsDirectory() {
+      return StringFromRegistryKey(ScriptsDirectoryKey);
+    }
+
+    public static string DefaultScriptsDirectory(){
+      return DefaultBasePath() + "\\Scripts";
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+      base.Dispose(disposing);
+    }
+
+    protected override void OnStart(string[] args)
+    {
+      base.OnStart(args);
+      ProcessWorker.Start();
+    }
+
+    protected override void OnStop()
+    {
+      base.OnStop();
+      ProcessWorker.Stop();
+    }
+
+  }
+}

data/win32/src/instrumental/InstrumentServerServiceInstaller.cs

@@ -0,0 +1,60 @@
+using Microsoft.Win32;
+
+using System;
+using System.Collections;
+using System.ComponentModel;
+using System.Configuration.Install;
+using System.ServiceProcess;
+
+namespace Instrumental
+{
+  [RunInstaller(true)]
+  public class InstrumentServerServiceInstaller : Installer
+  {
+
+    public const string PathArgument             = "Path";
+    public const string ConfigArgument           = "Config";
+    public const string HostnameArgument         = "Hostname";
+    public const string ScriptsDirectoryArgument = "ScriptsDirectory";
+    public const string ScriptsEnabledArgument   = "ScriptsEnabled";
+
+    public InstrumentServerServiceInstaller()
+    {
+      ServiceProcessInstaller serviceProcessInstaller = new ServiceProcessInstaller();
+      ServiceInstaller serviceInstaller               = new ServiceInstaller();
+
+      serviceProcessInstaller.Account                 = ServiceAccount.LocalService;
+      serviceProcessInstaller.Username                = null;
+      serviceProcessInstaller.Password                = null;
+
+      serviceInstaller.DisplayName                    = InstrumentServerService.NameOfService;
+      serviceInstaller.StartType                      = ServiceStartMode.Automatic;
+      serviceInstaller.ServiceName                    = InstrumentServerService.NameOfService;
+
+      this.Installers.Add(serviceProcessInstaller);
+      this.Installers.Add(serviceInstaller);
+    }
+
+    public override void Install(IDictionary savedState)
+    {
+      base.Install(savedState);
+
+      RegistryKey AppKey = InstrumentServerService.InstrumentalRegistryKey(true);
+      string Path        = Context.Parameters[PathArgument]             ?? InstrumentServerService.DefaultBasePath();
+      string Config      = Context.Parameters[ConfigArgument]           ?? InstrumentServerService.DefaultConfig();
+      string ScriptDir   = Context.Parameters[ScriptsDirectoryArgument] ?? InstrumentServerService.DefaultScriptsDirectory();
+      string Hostname    = Context.Parameters[HostnameArgument]         ?? InstrumentServerService.DefaultHostname();
+
+      bool EnableScripts = InstrumentServerService.DefaultScriptsEnabled();
+      if(Context.Parameters[ScriptsEnabledArgument] != null){
+        EnableScripts = Convert.ToBoolean(Context.Parameters[ScriptsEnabledArgument]);
+      }
+
+      AppKey.SetValue(InstrumentServerService.PathKey, Path);
+      AppKey.SetValue(InstrumentServerService.ConfigKey, Config);
+      AppKey.SetValue(InstrumentServerService.EnableScriptsKey, EnableScripts);
+      AppKey.SetValue(InstrumentServerService.ScriptsDirectoryKey, ScriptDir);
+      AppKey.SetValue(InstrumentServerService.HostnameKey, Hostname);
+    }
+  }
+}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: instrumental_tools
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.3
 platform: ruby
 authors:
 - Expected Behavior
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-21 00:00:00.000000000 Z
+date: 2015-08-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: instrumental_agent
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.12.6
+        version: 0.13.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.12.6
+        version: 0.13.2
 - !ruby/object:Gem::Dependency
   name: pidly
   requirement: !ruby/object:Gem::Requirement
@@ -178,13 +178,28 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: winrm-transport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 description: A collection of scripts useful for monitoring servers and services with
   Instrumental (instrumentalapp.com)
 email:
 - support@instrumentalapp.com
 executables:
 - instrument_server
-extensions: []
+extensions:
+- ext/mkrf_conf.rb
 extra_rdoc_files: []
 files:
 - BUILD.md
@@ -203,7 +218,9 @@ files:
 - chef/instrumental_tools/attributes/default.rb
 - chef/instrumental_tools/metadata.rb
 - chef/instrumental_tools/recipes/default.rb
-- chef/instrumental_tools/templates/instrumental.yml.erb
+- chef/instrumental_tools/templates/default/instrument_server.erb
+- chef/instrumental_tools/templates/default/instrumental.yml.erb
+- chef/omnibus.sh
 - conf/instrumental.yml
 - debian/after-install.sh
 - debian/after-remove.sh
@@ -216,6 +233,10 @@ files:
 - examples/mongo/mongo_3.rb
 - examples/mysql/README.md
 - examples/mysql/mysql_status.rb
+- examples/redis/README.md
+- examples/redis/redis_info.sh
+- ext/Rakefile
+- ext/mkrf_conf.rb
 - instrumental_tools.gemspec
 - lib/instrumental_tools/capistrano.rb
 - lib/instrumental_tools/metric_script_executor.rb
@@ -223,6 +244,7 @@ files:
 - lib/instrumental_tools/system_inspector.rb
 - lib/instrumental_tools/system_inspector/linux.rb
 - lib/instrumental_tools/system_inspector/osx.rb
+- lib/instrumental_tools/system_inspector/win32.rb
 - lib/instrumental_tools/version.rb
 - puppet/.kitchen.yml
 - puppet/.librarian/puppet/config
@@ -238,6 +260,13 @@ files:
 - rpm/instrument_server
 - systemd/instrument_server.service
 - test/integration/default/serverspec/instrumental_tools_spec.rb
+- win32/Makefile
+- win32/installer.nsis.erb
+- win32/logo.ico
+- win32/src/instrumental/InstrumentServerProcess.cs
+- win32/src/instrumental/InstrumentServerProcessWorker.cs
+- win32/src/instrumental/InstrumentServerService.cs
+- win32/src/instrumental/InstrumentServerServiceInstaller.cs
 homepage: http://github.com/expectedbehavior/instrumental_tools
 licenses:
 - MIT
@@ -258,7 +287,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Command line tools for Instrumental