cloudscale-monitor 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1624b78bda11e53b584dc7aa85db3bf7079f4139
+  data.tar.gz: 10b881bc72c6f577fa8ff2f70b3ff1926629dc0e
+SHA512:
+  metadata.gz: dd245aa8bde56eecfc12f52493be652afa78fd006f273270989cb75387239518673a9a5e8d7a7ea228170bb49d6074f75ac62a1b2e9a0fbf377ffc80b25594e2
+  data.tar.gz: b2b95de7b01d4694d8196efb12d7554cfc506cc55dc3ff769a236db09b035e723fba886fa51d0f7766394d1de2681773e5e6fc3d27f9cc9c3c85da53fefd784c

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Johannes Hiemer
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,33 @@
+# Cloudscale::Monitor
+
+Monitoring Client for the cloudscale Cloud Evaluation Platform
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'cloudscale-monitor'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install cloudscale-monitor
+    
+To prepare system for monitor execution, run bin/prepare_monitor.sh.
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/cloudscale-monitor/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/lib/cloudscale/monitor.rb

@@ -0,0 +1,131 @@
+require "optparse"
+require "singleton"
+require "yaml"
+require "json"
+require "#{File.dirname(__FILE__)}/monitor/version"
+require "#{File.dirname(__FILE__)}/monitor/agent/init"
+require "#{File.dirname(__FILE__)}/schedule"
+require "#{File.dirname(__FILE__)}/monitor/agent/preops/general_preop"
+require "#{File.dirname(__FILE__)}/plugins/plugin"
+require "#{File.dirname(__FILE__)}/plugins/preops/plugin_preop"
+Dir["#{File.dirname(__FILE__)}/plugins/*/*.rb"].each { | f | require f }
+
+##
+#
+# @author Johannes Hiemer, cloudscale.
+#
+##
+module Cloudscale
+  module Monitor
+    options = {}
+    mandatory = Array.new
+    mandatoryGeneral = Array.new
+      
+    scheduler = nil
+    
+    Plugins::PluginPreop.instance.init
+    Monitor::GeneralPreop.instance.init
+    
+    parser = OptionParser.new do | parser |
+      
+      parser.banner = "Usage: monitoring COMMAND [OPTIONS]"
+      parser.separator  ""
+      parser.separator  "Commands"
+      parser.separator  "     start:  Start cloudscale monitoring agent"
+      parser.separator  "     stop:   Stop cloudscale monitoring agent"
+      parser.separator  ""    
+      parser.separator  "     reset:  This resets the Chart, Table and Coredata specification settings. 
+               WARNING: Please be aware, that all collected data will be lost in your management environment."  
+      parser.separator  "     delete: This removes the complete cloudscale monitoring agent. WARNING: Please be aware, that all
+               collected data AND the agent will be lost in your management environment."
+      parser.separator  "Options"
+  
+      parser.on("-v", "--version", "Show version information about this program and quit.") do
+        puts "Cloudscale Monitoring " + VERSION
+        exit
+      end
+      
+      parser.separator "\n"
+      parser.separator "Monitoring specific Settings [Mandatory]"
+     
+      Monitor::GeneralPreop.instance.options.each do | key, value |
+        if (value[:required])
+          mandatoryGeneral.push(key)
+        end
+          parser.on(value[:argument][1,2] + " n", value[:argument] + "=n", value[:description]) do | value |
+            Monitor::GeneralPreop.instance.set_option_value(key, value)
+        end
+      end
+      
+      parser.separator "\n"
+      parser.separator "Plugin specific Settings [Mandatory]"
+      
+      Plugins::PluginPreop.instance.options.each do | key, value |
+        if (value[:required])
+          mandatory.push(key)
+        end
+        parser.on(value[:argument][1,2] + " n", value[:argument] + "=n", value[:description]) do | value |
+          Plugins::PluginPreop.instance.set_option_value(key, value)
+        end
+      end
+    end
+    
+    begin
+      parser.parse!
+      missingGeneral = mandatoryGeneral.select { | param |
+        Monitor::GeneralPreop.instance.get_option_value(param).nil?
+      }
+      missing = mandatory.select{ | param |
+        Plugins::PluginPreop.instance.get_option_value(param).nil?
+      }
+      if (!missing.empty? || !missingGeneral.empty?)
+        puts "\n"
+        puts "Error during execution: "
+        puts "     Missing general options: #{missingGeneral.join(', ')}"
+        puts "     Missing options: #{missing.join(', ')}"
+        puts "\n"
+        puts parser
+        exit
+      else
+        Plugins::PluginPreop.instance.save_options
+        Monitor::GeneralPreop.instance.save_options
+      end
+    rescue OptionParser::InvalidOption, OptionParser::MissingArgument
+      puts $!.to_s
+      puts parser
+      exit
+    end
+    
+    agent_instance = Monitor::Init.new(GeneralPreop.instance.get_option_value("token"))
+    agent_instance_id = agent_instance.agent_instance_id()
+    
+    case ARGV[0]
+      when "start"
+        plugins = Set.new
+        
+        Plugins::Plugin.plugins.each do | plugin_class |
+          plugin = plugin_class.new
+          plugins << plugin
+        end
+        
+        agent_instance.init_components()
+        agent_instance.init_menus()
+           
+        scheduler = Monitor::Schedule.new(plugins, agent_instance_id)
+      when "stop"
+        puts "call stop on options #{options.inspect}"      
+      when "reset"
+        puts "Starting cleanup process"
+        Plugins::Plugin.reset(agent_instance_id)
+        Plugins::PluginPreop.instance.clear_options
+      when "delete"
+        puts "Starting removal process"
+        Plugins::Plugin.remove(agent_instance_id)
+        Plugins::PluginPreop.instance.clear_options
+      else
+        puts parser
+    end
+  
+  end
+end
+   

data/lib/cloudscale/monitor/agent/init.rb

@@ -0,0 +1,95 @@
+require "yaml"
+require "logger"
+require "securerandom"
+require "#{File.dirname(__FILE__)}/../model/agent/agent_instance"
+require "#{File.dirname(__FILE__)}/../model/agent/agent_instance_settings"
+require "#{File.dirname(__FILE__)}/../model/constants/agent_instance_store"
+require "#{File.dirname(__FILE__)}/../model/constants/agent_store"
+require "#{File.dirname(__FILE__)}/../../rest/rest_client"
+require "#{File.dirname(__FILE__)}/init_components"
+require "#{File.dirname(__FILE__)}/init_menus"
+
+##
+#
+# @author Johannes Hiemer, cloudscale.
+#
+##
+module Cloudscale
+  module Monitor
+    class Init
+      attr_accessor :log, :agentInstanceId, :server, :client
+      def initialize(token)
+        @log = Logger.new(STDOUT)
+  
+        @server = Socket.gethostname
+        @agentInstanceId = SecureRandom.hex
+  
+        @client = RestClientWrapper.instance
+        
+        puts " "
+        puts "Running preflight verification for cloudscale monitoring agent"
+        
+        stored_agent_instance = Constants::AgentInstance.load
+        stored_agent = Constants::Agent.load
+        
+        if (stored_agent == nil)
+          raise "You did not provide any valid Agent file under /store/agent/agent.store."
+        end
+              
+        agent = client.searchOne('agents', 'findByAgentId', { :agentId => stored_agent["agentId"] })
+  
+        if (agent == nil)
+          raise "No agent registered yet. It is not allowed to connect this agent instance to cloudscale monitoring."
+        end
+  
+        if (stored_agent_instance != nil)
+          agent_instance = client.searchOne('agentInstances',
+          'findByAgentInstanceId', { :id => stored_agent_instance["agentInstanceId"] })
+        end
+  
+        if (agent_instance == nil)
+          puts "    No Instance of this agent was started previously, starting cloudscale monitoring agent for the first, registering..."
+  
+          agent_instance_settings = Monitor::Settings.new(15, 0, 1500, 5)
+          agent_instance = Monitor::AgentInstance.new(RestClientWrapper.load_entity_ref(agent)["href"],
+            agentInstanceId, token, server, agent_instance_settings, Time.now.to_i * 1000)
+  
+          client.post('agentInstances', agent_instance)
+          Constants::AgentInstance.create(agent_instance.to_h)
+        else
+          puts "    Instance has been started previously, loading settings and existing data... \n\n"
+  
+          @agentInstanceId = agent_instance["agentInstanceId"]
+          agent_instance["lastInitialization"] = Time.now.to_i * 1000
+          agent_instance["agent"] = RestClientWrapper.load_entity_ref(agent)["href"]
+  
+          client.put('agentInstances', RestClientWrapper.load_entity_id(agent_instance), agent_instance)
+        end
+        
+        Monitor::InitComponents.setup_components()
+        Monitor::InitMenus.setup_menus()
+      end
+      
+      def agent_instance_id
+        return agentInstanceId
+      end
+  
+      def init_components
+        log.info("Starting cloudscale Monitoring Components synchronization...")
+  
+        Monitor::InitComponents.new(@agentInstanceId)
+  
+        log.info("Successfully synchronized cloudscale Monitoring Components...")
+      end
+      
+      def init_menus
+         log.info("Starting cloudscale Monitoring Menu synchronization...")
+   
+         Monitor::InitMenus.new(@agentInstanceId)
+   
+         log.info("Successfully synchronized cloudscale Menu Components...")
+       end
+   
+    end
+  end
+end

data/lib/cloudscale/monitor/agent/init_components.rb

@@ -0,0 +1,88 @@
+require "yaml"
+require "logger"
+require "#{File.dirname(__FILE__)}/../../plugins/definition/plugin_components"
+require "#{File.dirname(__FILE__)}/../../rest/rest_client"
+
+##
+#
+# @author Johannes Hiemer, cloudscale.
+#
+##
+module Cloudscale
+  module Monitor
+    class InitComponents
+      attr_accessor :log, :customer, :agentInstanceId, :server, :client
+      
+      def initialize(agentInstanceId)
+        if (agentInstanceId == nil)
+          raise "InitComponents.new(): AgentInstanceId may not be null"
+        end
+        
+        @log = Logger.new(STDOUT)
+        @log.info("Initializing Component")
+        @client = RestClientWrapper.instance
+        
+        displayUnits = client.list_with_params('units', { :size => 100 })
+        
+        plugin = Plugins::PluginComponents.load_hash()
+        plugin.each do | key, value |
+          init_component(value, agentInstanceId, displayUnits)
+        end
+      end
+      
+      def init_component(component, agentInstanceId, displayUnits)
+        component["metrics"].each { | metric |
+          select_units(displayUnits, metric)
+        }
+        component["agentInstanceId"] = agentInstanceId
+        test_component = @client.searchOne("components", "findByAgentInstanceIdAndName", { :agentInstanceId => agentInstanceId, :name => component["name"]})
+        if (test_component == nil)
+          client.post("components", component)
+        else
+          client.put("components", RestClientWrapper.load_entity_id(test_component), component)
+        end
+      end
+      
+      def select_units(displayUnits, metric)     
+        unit = load_unit(displayUnits["content"], metric["units"]["unit"])    
+        divisor = load_unit(displayUnits["content"], metric["units"]["divisor"])
+        
+        metric["units"]["unit"] = nil
+        if (unit != nil)
+          metric["units"]["unit"] = RestClientWrapper.load_entity_ref(unit)["href"]
+        end
+        
+        metric["units"]["divisor"] = nil
+        if (divisor != nil)
+          metric["units"]["divisor"] = RestClientWrapper.load_entity_ref(divisor)["href"]
+        end    
+        
+        if (metric["units"]["unit"] == nil && metric["units"]["divisor"] == nil)
+          metric["units"] = nil
+        end
+      end 
+      
+      def load_unit(units, id)
+        if (units.is_a?(Array))
+          units.each { | unit |
+            if (unit["unitId"] == id)
+              return unit
+            end
+          }
+        end
+        return nil
+      end
+      
+      def self.setup_components
+        if (!Plugins::PluginComponents.is_initialized())
+          Plugins::PluginComponents.init_components()
+        end
+      end
+     
+      def self.remove_components
+        Plugins::PluginComponents.remove_components()
+      end
+      
+    end
+  end
+end

data/lib/cloudscale/monitor/agent/init_menus.rb

@@ -0,0 +1,53 @@
+require "yaml"
+require "logger"
+require "#{File.dirname(__FILE__)}/../../plugins/definition/plugin_menus_mongodb"
+require "#{File.dirname(__FILE__)}/../../rest/rest_client"
+
+##
+#
+# @author Johannes Hiemer, cloudscale.
+#
+##
+module Cloudscale
+  module Monitor
+    class InitMenus
+      attr_accessor :log, :customer, :agentInstanceId, :server, :client
+      
+      def initialize(agentInstanceId)
+        if (agentInstanceId == nil)
+          raise "InitMenu.new(): AgentInstanceId may not be null"
+        end
+        
+        @log = Logger.new(STDOUT)
+        @log.info("Initializing Menu")
+        @client = RestClientWrapper.instance
+        
+        plugin = Plugins::PluginMenus.load_hash()
+        plugin.each do | key, value |
+          init_menu(value, agentInstanceId)
+        end
+      end
+      
+      def init_menu(menuItem, agentInstanceId)
+        menuItem["agentInstanceId"] = agentInstanceId
+        test_menu = @client.searchOne("agentInstanceMenus", "findByAgentInstanceIdAndName", { :agentInstanceId => agentInstanceId, :name => menuItem["name"]})
+        if (test_menu == nil)
+          client.post("agentInstanceMenus", menuItem)
+        else
+          client.put("agentInstanceMenus", RestClientWrapper.load_entity_id(test_menu), menuItem)
+        end
+      end
+      
+      def self.setup_menus
+        if (!Plugins::PluginMenus.is_initialized())
+          Plugins::PluginMenus.init_menus()
+        end
+      end
+     
+      def self.remove_menus
+        Plugins::PluginMenus.remove_menus()
+      end
+      
+    end
+  end
+end

data/lib/cloudscale/monitor/agent/preops/general_preop.rb

@@ -0,0 +1,35 @@
+require "optparse"
+require "logger"
+require "sigar"
+require "#{File.dirname(__FILE__)}/preop"
+
+##
+#
+# @author Johannes Hiemer, cloudscale.
+#
+##
+module Cloudscale
+  module Monitor
+    class GeneralPreop < Preops::Preop
+      include Singleton
+      
+      @@options = {
+        :token => {
+          :argument => "--token",
+          :description => "The Token, which is automatically generated in your Account for Monitoring",
+          :required => true,
+          :value => nil     
+        },
+      }
+      
+      def options      
+        @@options
+      end
+      
+      def initialize
+        self.init
+      end
+      
+    end
+  end
+end