diff --git a/install.sh b/install.sh index c99f29d712..d17be6f113 100755 --- a/install.sh +++ b/install.sh @@ -193,7 +193,8 @@ LIB_DIRS="$LIB_LOCATION/ruby \ $LIB_LOCATION/mads \ $LIB_LOCATION/sh \ $LIB_LOCATION/ruby/cli \ - $LIB_LOCATION/ruby/cli/one_helper" + $LIB_LOCATION/ruby/cli/one_helper \ + $LIB_LOCATION/ruby/acct" VAR_DIRS="$VAR_LOCATION/remotes \ $VAR_LOCATION/remotes/im \ @@ -300,6 +301,8 @@ INSTALL_FILES=( MAN_FILES:$MAN_LOCATION CLI_LIB_FILES:$LIB_LOCATION/ruby/cli ONE_CLI_LIB_FILES:$LIB_LOCATION/ruby/cli/one_helper + ACCT_LIB_FILES:$LIB_LOCATION/ruby/acct + ACCT_BIN_FILES:$BIN_LOCATION ) INSTALL_CLIENT_FILES=( @@ -362,6 +365,7 @@ INSTALL_ETC_FILES=( OCCI_ETC_FILES:$ETC_LOCATION OCCI_ETC_TEMPLATE_FILES:$ETC_LOCATION/occi_templates CLI_CONF_FILES:$ETC_LOCATION/cli + ACCT_ETC_FILES:$ETC_LOCATION ) #------------------------------------------------------------------------------- @@ -912,6 +916,20 @@ SUNSTONE_PUBLIC_IMAGES_FILES="src/sunstone/public/images/ajax-loader.gif \ src/sunstone/public/images/vnc_off.png \ src/sunstone/public/images/vnc_on.png" +#----------------------------------------------------------------------------- +# ACCT files +#----------------------------------------------------------------------------- + +ACCT_BIN_FILES="src/acct/acctd" + +ACCT_LIB_FILES="src/acct/monitoring.rb \ + src/acct/accounting.rb \ + src/acct/acctd.rb \ + src/acct/watch_helper.rb \ + src/acct/watch_client.rb" + +ACCT_ETC_FILES="src/acct/etc/acctd.conf" + #----------------------------------------------------------------------------- # MAN files #----------------------------------------------------------------------------- diff --git a/src/acct/accounting.rb b/src/acct/accounting.rb new file mode 100644 index 0000000000..1fd0c6b8ac --- /dev/null +++ b/src/acct/accounting.rb @@ -0,0 +1,114 @@ +module OneWatch + require 'watch_helper' + + class Accounting + def initialize(client) + @client = client + @active_vms = Array.new + end + + def insert(hash) + @ptimestamp = @timestamp + @timestamp = generate_timestamp + + new_active_vms = Array.new + last_active_vm = @active_vms.empty? ? -1 : @active_vms.last + + if (vmpool_hash = hash['VM_POOL']) && !vmpool_hash.empty? + [vmpool_hash['VM']].flatten.each { |vm| + vm_id = vm['ID'].to_i + + if vm['STATE'] == 3 + new_active_vms << vm_id + end + + # ACTIVE VMs (including those that are stopped in this step) + # in the last step and NEW VMs + if @active_vms.include?(vm_id) || vm['STATE'].to_i == 3 + insert_vm(vm) + @active_vms.delete(vm_id) + else + # DONE/STOP VMs and non ACTIVE in the last step + next + end + } + end + + # DONE VMs that were ACTIVE in the last step + @active_vms.each { |id| + vm = OpenNebula::VirtualMachine.new_with_id(id, @client) + vm.info + + vm_hash = vm.to_hash + insert_vm(vm_hash) + } + + # DONE VMs that did not exist in the last step + vmpool = OpenNebula::VirtualMachinePool.new(@client) + vmpool.info(-2, last_active_vm, -1, 6) + done_hash = vmpool.to_hash + if (done_vm_hash = done_hash['VM_POOL']) && !done_vm_hash.empty? + [done_vm_hash['VM']].flatten.each { |vm| + insert_vm(vm) + } + end + + # Upate the active VMs + @active_vms = new_active_vms.sort + + WatchHelper::Vm.flush + end + + private + + def generate_timestamp + Time.now.to_i + end + + def insert_register(vm, register, history) + if register && register.seq == history['SEQ'].to_i + register.update_from_history(history) + else + vm.add_register_from_resource(history) + end + end + + def update_history(vm, vm_sql) + last_register = vm_sql.registers.last + seq = last_register ? last_register.seq : 0 + + if hr = vm['HISTORY_RECORDS'] + unless hr['HISTORY'].instance_of?(Array) + if hr['HISTORY']['SEQ'] == seq + # The VM has not moved from the Host + insert_register(vm_sql, last_register, hr['HISTORY']) + return + else + # Get the full HISTORY + vm = OpenNebula::VirtualMachine.new_with_id(vm['ID'], @client) + vm.info + + vm_hash = vm.to_hash['VM'] + hr = vm_hash['HISTORY_RECORDS'] + + # Insert a new entry for each new history record + [hr['HISTORY']].flatten.each { |history| + if history['SEQ'].to_i < seq + next + else + insert_register(vm_sql, last_register, history) + end + } + end + end + end + end + + def insert_vm(vm) + vm_sql = WatchHelper::Vm.info(vm) + vm_sql.add_delta_from_resource(vm, @timestamp) + update_history(vm, vm_sql) + end + end +end + diff --git a/src/acct/acctd b/src/acct/acctd new file mode 100755 index 0000000000..5b0a8283bc --- /dev/null +++ b/src/acct/acctd @@ -0,0 +1,82 @@ +#!/bin/bash + +# -------------------------------------------------------------------------- # +# Copyright 2002-2011, OpenNebula Project Leads (OpenNebula.org) # +# # +# Licensed under the Apache License, Version 2.0 (the "License"); you may # +# not use this file except in compliance with the License. You may obtain # +# a copy of the License at # +# # +# http://www.apache.org/licenses/LICENSE-2.0 # +# # +# Unless required by applicable law or agreed to in writing, software # +# distributed under the License is distributed on an "AS IS" BASIS, # +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # +# See the License for the specific language governing permissions and # +# limitations under the License. # +#--------------------------------------------------------------------------- # + +if [ -z "$ONE_LOCATION" ]; then + ONE_PID=/var/run/one/oned.pid + LOCK_FILE=/var/lock/one/one + ACCTD_CMD=/usr/lib/one/ruby/acct/acctd.rb + ACCTD_LOG=/var/log/one/acctd.log + ACCTD_PID_FILE=/var/run/one/acctd.pid +else + ONE_PID=$ONE_LOCATION/var/oned.pid + LOCK_FILE=$ONE_LOCATION/var/.lock + ACCTD_CMD=$ONE_LOCATION/lib/ruby/acct/acctd.rb + ACCTD_LOG=$ONE_LOCATION/var/acctd.log + ACCTD_PID_FILE=$ONE_LOCATION/var/acctd.pid +fi + +function oned_running { + ONEPID=`cat $ONE_PID 2> /dev/null` + ps $ONEPID > /dev/null 2>&1 + if [ ! -f "$LOCK_FILE" -o ! -f "$ONE_PID" -o $? -ne 0 ]; then + echo not running + exit 1 + fi +} + +function acctd_running { + ACCTD_PID=`cat $ACCTD_PID_FILE 2>/dev/null` + ps "$ACCTD_PID" &> /dev/null +} + +COMMAND=$1 + +case $COMMAND in +start) + # check if OpenNebula running + oned_running + + # check if acct already running + acctd_running + if [ "$?" = "0" ]; then + echo "acctd already running." + exit 1 + fi + + # acctd not running, safe to start + $ACCTD_CMD &> $ACCTD_LOG & + echo $! > $ACCTD_PID_FILE + ;; +stop) + # check if running + acctd_running + if [ "$?" != "0" ]; then + echo "acctd not running." + exit 1 + fi + + # acctd running, safe to stop + ACCTD_PID=`cat $ACCTD_PID_FILE 2>/dev/null` + kill $ACCTD_PID &> /dev/null + rm -f $ACCTD_PID_FILE &> /dev/null + ;; +*) + echo "Usage: acctd {start|stop}" >&2 + exit 3 + ;; +esac diff --git a/src/acct/acctd.rb b/src/acct/acctd.rb new file mode 100755 index 0000000000..3134e07976 --- /dev/null +++ b/src/acct/acctd.rb @@ -0,0 +1,139 @@ +#!/usr/bin/env ruby + +# -------------------------------------------------------------------------- # +# Copyright 2002-2011, OpenNebula Project Leads (OpenNebula.org) # +# # +# Licensed under the Apache License, Version 2.0 (the "License"); you may # +# not use this file except in compliance with the License. You may obtain # +# a copy of the License at # +# # +# http://www.apache.org/licenses/LICENSE-2.0 # +# # +# Unless required by applicable law or agreed to in writing, software # +# distributed under the License is distributed on an "AS IS" BASIS, # +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # +# See the License for the specific language governing permissions and # +# limitations under the License. # +#--------------------------------------------------------------------------- # + +ONE_LOCATION=ENV["ONE_LOCATION"] + +if !ONE_LOCATION + RUBY_LIB_LOCATION="/usr/lib/one/ruby" + ACCTD_CONF="/etc/one/acctd.conf" +else + RUBY_LIB_LOCATION=ONE_LOCATION+"/lib/ruby" + ACCTD_CONF=ONE_LOCATION+"/etc/acctd.conf" +end + +$: << RUBY_LIB_LOCATION +$: << RUBY_LIB_LOCATION+"/acct" + +require 'yaml' + +require 'OpenNebula' +require 'watch_helper' + +class Watcher + def initialize + @monitors = Array.new + end + + def add(resource, steps, pools) + @monitors << { :resource => resource, + :steps => steps, + :pools => [pools].flatten + } + end + + def log(msg) + STDERR.puts "#{Time.now} #{msg}" + end + + def update(step) + # clear pool cache + @pool_cache = Hash.new + + @monitors.each do |monitor| + if monitor[:steps] > 0 and step % monitor[:steps] == 0 + monitor[:pools].each do |pool| + resource = monitor[:resource] + + log "#{resource.class}" + + if pool_hash = @pool_cache[pool] + else + rc = pool.info + if OpenNebula.is_error?(rc) + log "Error: " + rc.message + log "Shutting down" + exit 1 + end + + pool_hash = pool.to_hash + @pool_cache[pool] = pool_hash + end + + resource.insert(pool_hash) + end + end + end + end +end + +watcher = Watcher.new + +# OpenNebula variables +one_client = OpenNebula::Client.new +vm_pool = nil # common for accounting and monitoring +host_pool = nil + +# Initialize VM monitoring +if vm_steps = WatchHelper::get_config(:VM_MONITORING, :STEPS) and + vm_steps > 0 + + require 'monitoring' + vm_monitoring = OneWatch::VmMonitoring.new + vm_pool ||= OpenNebula::VirtualMachinePool.new(one_client, -2) + watcher.add(vm_monitoring, vm_steps, vm_pool) +end + +# Initialize Host monitoring +if host_steps = WatchHelper::get_config(:HOST_MONITORING, :STEPS) and + host_steps > 0 + + require 'monitoring' + host_monitoring = OneWatch::HostMonitoring.new + host_pool ||= OpenNebula::HostPool.new(one_client) + watcher.add(host_monitoring, host_steps, host_pool) +end + +# Initialize accounting +if accounting_steps = WatchHelper::get_config(:ACCOUNTING, :STEPS) and + accounting_steps > 0 + + require 'accounting' + accounting = OneWatch::Accounting.new(one_client) + vm_pool ||= OpenNebula::VirtualMachinePool.new(one_client, -2) + watcher.add(accounting, accounting_steps, vm_pool) +end + +step_time = WatchHelper::get_config(:STEP) + +step = 0 +loop do + start_time = Time.now + expected_end_time = start_time + step_time + + step += 1 + watcher.update(step) + + end_time = Time.now + sleep_time = start_time + step_time - end_time + + if sleep_time >= 1 + sleep sleep_time + else + sleep 1 + end +end diff --git a/src/acct/etc/acctd.conf b/src/acct/etc/acctd.conf new file mode 100644 index 0000000000..7b4e099817 --- /dev/null +++ b/src/acct/etc/acctd.conf @@ -0,0 +1,55 @@ +# -------------------------------------------------------------------------- # +# Copyright 2002-2011, OpenNebula Project Leads (OpenNebula.org) # +# # +# Licensed under the Apache License, Version 2.0 (the "License"); you may # +# not use this file except in compliance with the License. You may obtain # +# a copy of the License at # +# # +# http://www.apache.org/licenses/LICENSE-2.0 # +# # +# Unless required by applicable law or agreed to in writing, software # +# distributed under the License is distributed on an "AS IS" BASIS, # +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # +# See the License for the specific language governing permissions and # +# limitations under the License. # +#--------------------------------------------------------------------------- # + +# Database URI +:DB: sqlite:///tmp/test_one_acct.db + +# Duration of each daemon loop in seconds +:STEP: 300 # 5 minutes + +#------------------------------------------------------------------------------- +# VM Monitoring +#------------------------------------------------------------------------------- + +:VM_MONITORING: + + # Number of daemon loops until a VM monitoring watch + :STEPS: 1 + + # Number of VM records to preserve + :WINDOW_SIZE: 5 + +#------------------------------------------------------------------------------- +# HOST Monitoring +#------------------------------------------------------------------------------- + +:HOST_MONITORING: + + # Number of daemon loops until a Hosts monitoring watch + :STEPS: 3 + + # Number of HOST records to preserve + :WINDOW_SIZE: 5 + +#------------------------------------------------------------------------------- +# Accounting +#------------------------------------------------------------------------------- + +:ACCOUNTING: + + # Number of daemon loops until an accounting watch + :STEPS: 10 + diff --git a/src/acct/examples/acct_client.rb b/src/acct/examples/acct_client.rb new file mode 100644 index 0000000000..73ebbee8b5 --- /dev/null +++ b/src/acct/examples/acct_client.rb @@ -0,0 +1,75 @@ +require 'watch_helper' + +class AcctClient + def prolog_time(t1, t2, opts={}) + times(t1, t2, opts) { |reg| + calculate_time(t1, t2, reg.pstime, reg.petime) + } + end + + def running_time(t1, t2, opts={}) + # TBD Suspened VMs + + times(t1, t2, opts) { |reg| + calculate_time(t1, t2, reg.rstime, reg.retime) + } + end + + def epilog_time(t1, t2, opts={}) + times(t1, t2, opts) { |reg| + calculate_time(t1, t2, reg.estime, reg.eetime) + } + end + + private + + def times(t1, t2, opts={}, &block) + time = 0 + + vms = filter_vms(opts) + + if vms && !vms.empty? + vms.each { |vm| + vm.registers.each { |reg| + time += block.call(reg) + } + } + end + + time + end + + def calculate_time(t1, t2, stime, etime) + if etime < t1 && etime != 0 + return 0 + elsif stime < t2 && stime != 0 + if etime < t2 && etime != 0 + e = etime + else + e = t2 + end + + s = stime > t1 ? stime : t1 + return e - s + end + + return 0 + end + + def filter_vms(opts={}) + opts ||= {} + + if opts[:uid] + vms = WatchHelper::Vm.filter(:uid=>opts[:uid]) + elsif opts[:gid] + vms = WatchHelper::Vm.filter(:gid=>opts[:gid]) + elsif opts[:hid] + vms = WatchHelper::Vm.filter( + :registers=>WatchHelper::Register.filter(:hid => opts[:hid])) + elsif opts[:vmid] + vms = WatchHelper::Vm.filter(:id=>opts[:vmid]) + else + vms = WatchHelper::Vm + end + end +end diff --git a/src/acct/monitoring.rb b/src/acct/monitoring.rb new file mode 100644 index 0000000000..14bc5959b8 --- /dev/null +++ b/src/acct/monitoring.rb @@ -0,0 +1,52 @@ +module OneWatch + require 'watch_helper' + + class Monitoring + def insert(hash) + timestamp = generate_timestamp + + if (pool_hash = hash["#{resource}_POOL"]) && !pool_hash.empty? + [pool_hash["#{resource}"]].flatten.each { |elem| + sql = sql_elem(elem) + sql.add_sample_from_resource(elem, timestamp) + } + end + + sql_elem.flush + end + + private + + def generate_timestamp + Time.now.to_i + end + end + + class VmMonitoring < Monitoring + def resource + 'VM' + end + + def sql_elem(elem=nil) + if elem + WatchHelper::Vm.info(elem) + else + WatchHelper::Vm + end + end + end + + class HostMonitoring < Monitoring + def resource + 'HOST' + end + + def sql_elem(elem=nil) + if elem + WatchHelper::Host.info(elem) + else + WatchHelper::Host + end + end + end +end diff --git a/src/acct/test/1Vm1His.rb b/src/acct/test/1Vm1His.rb new file mode 100644 index 0000000000..0dad640a1c --- /dev/null +++ b/src/acct/test/1Vm1His.rb @@ -0,0 +1,333 @@ +require 'helper/test_helper.rb' + +describe "1 Vm 1 History" do + before(:each) do + clean_db + + @mock_client = MockClient.new + @accounting = OneWatch::Accounting.new(@mock_client) + + @watch_client = AcctClient.new + + @db = WatchHelper::DB + check_lines(0,0) + end + + it "Prolog testing" do + ts1 = 100 + @accounting.set_mock_timestamp(ts1) + + @accounting.insert(create_vmpool_hash) + check_lines(0,0) + + ts2 = 200 + @accounting.set_mock_timestamp(ts2) + + values = { + :uid => 2, + :gid => 4, + :history => [ + :hid => 7, + :pstime => 150, + :petime => 0, + :rstime => 0, + :retime => 0, + :estime => 0, + :eetime => 0, + :reason => 0 + ] + } + + @mock_client.add_vm(1, values) + + @accounting.insert(create_vmpool_hash) + check_lines(1,1) + + history = values[:history].first + sum = ts2 - history[:pstime] + + warn "* T1 PSTIME T2" + @watch_client.prolog_time(ts1, ts2).to_i.should eql(sum) + warn " - By User" + @watch_client.prolog_time(ts1, ts2, :uid => 2).to_i.should eql(sum) + warn " - By Host" + @watch_client.prolog_time(ts1, ts2, :hid => 7).to_i.should eql(sum) + warn " - By Vm" + @watch_client.prolog_time(ts1, ts2, :vmid => 1).to_i.should eql(sum) + + warn " - Non existent User" + @watch_client.prolog_time(ts1, ts2, :uid => 555).to_i.should eql(0) + warn " - Non existent Host" + @watch_client.prolog_time(ts1, ts2, :hid => 555).to_i.should eql(0) + warn " - Non existent Vm" + @watch_client.prolog_time(ts1, ts2, :vmid => 555).to_i.should eql(0) + + warn "* PSTIME T1 T2" + @watch_client.prolog_time(160, ts2).to_i.should eql(sum-10) + warn "* T1 PSTIME T2-10" + @watch_client.prolog_time(ts1, ts2-10).to_i.should eql(sum-10) + warn "* T1 T2 PSTIME" + @watch_client.prolog_time(110, 130).to_i.should eql(0) + + warn "* Non Epilog time" + @watch_client.epilog_time(ts1, ts2).to_i.should eql(0) + warn "* Non Running time" + @watch_client.running_time(ts1, ts2).to_i.should eql(0) + + ts3 = 300 + @accounting.set_mock_timestamp(ts3) + + values = { + :uid => 2, + :gid => 4, + :history => [ + :hid => 7, + :pstime => 150, + :petime => 240, + :rstime => 0, + :retime => 0, + :estime => 0, + :eetime => 0, + :reason => 0 + ] + } + + @mock_client.add_vm(1, values) + + @accounting.insert(create_vmpool_hash) + check_lines(1,1) + + history = values[:history].first + sum = history[:petime] - history[:pstime] + + warn "* T1 PSTIME PETIME T3" + @watch_client.prolog_time(ts1, ts3).to_i.should eql(sum) + warn " - By User" + @watch_client.prolog_time(ts1, ts3, :uid => 2).to_i.should eql(sum) + warn " - By Host" + @watch_client.prolog_time(ts1, ts3, :hid => 7).to_i.should eql(sum) + warn " - By Vm" + @watch_client.prolog_time(ts1, ts3, :vmid => 1).to_i.should eql(sum) + + warn "* T1 PSTIME T3 PETIME" + @watch_client.prolog_time(ts1, 230).to_i.should eql(230 - history[:pstime]) + + warn "* PSTIME T1 PETIME T3" + @watch_client.prolog_time(160, ts3).to_i.should eql(history[:petime] - 160) + + warn "* PSTIME T1 T3 PETIME" + @watch_client.prolog_time(160, 230).to_i.should eql(230 - 160) + end + + it "Running testing" do + ts1 = 100 + @accounting.set_mock_timestamp(ts1) + + @accounting.insert(create_vmpool_hash) + check_lines(0,0) + + ts2 = 200 + @accounting.set_mock_timestamp(ts2) + + values = { + :uid => 2, + :gid => 4, + :history => [ + :hid => 7, + :pstime => 150, + :petime => 155, + :rstime => 155, + :retime => 0, + :estime => 0, + :eetime => 0, + :reason => 0 + ] + } + + @mock_client.add_vm(1, values) + + @accounting.insert(create_vmpool_hash) + check_lines(1,1) + + history = values[:history].first + sum = ts2 - history[:rstime] + + warn "* T1 RSTIME T2" + @watch_client.running_time(ts1, ts2).to_i.should eql(sum) + warn " - By User" + @watch_client.running_time(ts1, ts2, :uid => 2).to_i.should eql(sum) + warn " - By Host" + @watch_client.running_time(ts1, ts2, :hid => 7).to_i.should eql(sum) + warn " - By Vm" + @watch_client.running_time(ts1, ts2, :vmid => 1).to_i.should eql(sum) + + warn " - Non existent User" + @watch_client.running_time(ts1, ts2, :uid => 555).to_i.should eql(0) + warn " - Non existent Host" + @watch_client.running_time(ts1, ts2, :hid => 555).to_i.should eql(0) + warn " - Non existent Vm" + @watch_client.running_time(ts1, ts2, :vmid => 555).to_i.should eql(0) + + warn "* RSTIME T1 T2" + @watch_client.running_time(160, ts2).to_i.should eql(ts2-160) + warn "* T1 RSTIME T2-10" + @watch_client.running_time(ts1, ts2-10).to_i.should eql(sum-10) + warn "* T1 T2 RSTIME" + @watch_client.running_time(110, 130).to_i.should eql(0) + + warn "* Non Epilog time" + @watch_client.epilog_time(ts1, ts2).to_i.should eql(0) + warn "* Non Prolog time" + @watch_client.prolog_time(ts1, ts2).to_i.should eql(5) + + ts3 = 300 + @accounting.set_mock_timestamp(ts3) + + values = { + :uid => 2, + :gid => 4, + :history => [ + :hid => 7, + :pstime => 150, + :petime => 155, + :rstime => 155, + :retime => 230, + :estime => 0, + :eetime => 0, + :reason => 0 + ] + } + + @mock_client.add_vm(1, values) + + @accounting.insert(create_vmpool_hash) + check_lines(1,1) + + history = values[:history].first + sum = history[:retime] - history[:rstime] + + warn "* T1 PSTIME PETIME T3" + @watch_client.running_time(ts1, ts3).to_i.should eql(sum) + warn " - By User" + @watch_client.running_time(ts1, ts3, :uid => 2).to_i.should eql(sum) + warn " - By Host" + @watch_client.running_time(ts1, ts3, :hid => 7).to_i.should eql(sum) + warn " - By Vm" + @watch_client.running_time(ts1, ts3, :vmid => 1).to_i.should eql(sum) + + warn "* T1 PSTIME T3 PETIME" + @watch_client.running_time(ts1, 230).to_i.should eql(230 - history[:rstime]) + + warn "* PSTIME T1 PETIME T3" + @watch_client.running_time(160, ts3).to_i.should eql(history[:retime] - 160) + + warn "* PSTIME T1 T3 PETIME" + @watch_client.running_time(160, 230).to_i.should eql(230 - 160) + end + + it "Epilog testing" do + ts1 = 100 + @accounting.set_mock_timestamp(ts1) + + @accounting.insert(create_vmpool_hash) + check_lines(0,0) + + ts2 = 200 + @accounting.set_mock_timestamp(ts2) + + values = { + :uid => 2, + :gid => 4, + :history => [ + :hid => 7, + :pstime => 150, + :petime => 155, + :rstime => 155, + :retime => 170, + :estime => 180, + :eetime => 0, + :reason => 0 + ] + } + + @mock_client.add_vm(1, values) + + @accounting.insert(create_vmpool_hash) + check_lines(1,1) + + history = values[:history].first + sum = ts2 - history[:estime] + + warn "* T1 ESTIME T2" + @watch_client.epilog_time(ts1, ts2).to_i.should eql(sum) + warn " - By User" + @watch_client.epilog_time(ts1, ts2, :uid => 2).to_i.should eql(sum) + warn " - By Host" + @watch_client.epilog_time(ts1, ts2, :hid => 7).to_i.should eql(sum) + warn " - By Vm" + @watch_client.epilog_time(ts1, ts2, :vmid => 1).to_i.should eql(sum) + + warn " - Non existent User" + @watch_client.epilog_time(ts1, ts2, :uid => 555).to_i.should eql(0) + warn " - Non existent Host" + @watch_client.epilog_time(ts1, ts2, :hid => 555).to_i.should eql(0) + warn " - Non existent Vm" + @watch_client.epilog_time(ts1, ts2, :vmid => 555).to_i.should eql(0) + + warn "* ESTIME T1 T2" + @watch_client.epilog_time(190, ts2).to_i.should eql(ts2-190) + warn "* T1 ESTIME T2-10" + @watch_client.epilog_time(ts1, ts2-10).to_i.should eql(sum-10) + warn "* T1 T2 ESTIME" + @watch_client.epilog_time(110, 130).to_i.should eql(0) + + warn "* Non Running time" + @watch_client.running_time(ts1, ts2).to_i.should eql(15) + warn "* Non Prolog time" + @watch_client.prolog_time(ts1, ts2).to_i.should eql(5) + + ts3 = 300 + @accounting.set_mock_timestamp(ts3) + + values = { + :uid => 2, + :gid => 4, + :history => [ + :hid => 7, + :pstime => 150, + :petime => 155, + :rstime => 155, + :retime => 170, + :estime => 180, + :eetime => 230, + :reason => 0 + ] + } + + @mock_client.add_vm(1, values) + + @accounting.insert(create_vmpool_hash) + check_lines(1,1) + + history = values[:history].first + sum = history[:eetime] - history[:estime] + + warn "* T1 PSTIME PETIME T3" + @watch_client.epilog_time(ts1, ts3).to_i.should eql(sum) + warn " - By User" + @watch_client.epilog_time(ts1, ts3, :uid => 2).to_i.should eql(sum) + warn " - By Host" + @watch_client.epilog_time(ts1, ts3, :hid => 7).to_i.should eql(sum) + warn " - By Vm" + @watch_client.epilog_time(ts1, ts3, :vmid => 1).to_i.should eql(sum) + + warn "* T1 PSTIME T3 PETIME" + @watch_client.epilog_time(ts1, 230).to_i.should eql(230 - history[:estime]) + + warn "* PSTIME T1 PETIME T3" + @watch_client.epilog_time(190, ts3).to_i.should eql(history[:eetime] - 190) + + warn "* PSTIME T1 T3 PETIME" + @watch_client.epilog_time(190, 220).to_i.should eql(220 - 190) + end +end \ No newline at end of file diff --git a/src/acct/test/1VmXHis.rb b/src/acct/test/1VmXHis.rb new file mode 100644 index 0000000000..d0a94a0840 --- /dev/null +++ b/src/acct/test/1VmXHis.rb @@ -0,0 +1,99 @@ +require 'helper/test_helper.rb' + +describe "1 Vm X History" do + before(:each) do + clean_db + + @mock_client = MockClient.new + @accounting = OneWatch::Accounting.new(@mock_client) + + @watch_client = AcctClient.new + + @db = WatchHelper::DB + check_lines(0,0) + end + + it "Running testing" do + ts1 = 100 + @accounting.set_mock_timestamp(ts1) + + @accounting.insert(create_vmpool_hash) + check_lines(0,0) + + ts2 = 200 + @accounting.set_mock_timestamp(ts2) + + values = { + :uid => 2, + :gid => 4, + :history => [ + :hid => 7, + :seq => 0, + :pstime => 150, + :petime => 155, + :rstime => 155, + :retime => 0, + :estime => 0, + :eetime => 0, + :reason => 0 + ] + } + + @mock_client.add_vm(1, values) + + @accounting.insert(create_vmpool_hash) + check_lines(1,1) + + history = values[:history].first + sum = ts2 - history[:rstime] + + warn "* T1 RSTIME T2" + @watch_client.running_time(ts1, ts2).to_i.should eql(sum) + + ts3 = 300 + @accounting.set_mock_timestamp(ts3) + + values = { + :uid => 2, + :gid => 4, + :history => [ + { + :hid => 7, + :seq => 0, + :pstime => 150, + :petime => 155, + :rstime => 155, + :retime => 230, + :estime => 230, + :eetime => 260, + :reason => 2 + }, + { + :hid => 8, + :seq => 1, + :pstime => 270, + :petime => 275, + :rstime => 275, + :retime => 0, + :estime => 0, + :eetime => 0, + :reason => 0 + } + ] + } + + @mock_client.add_vm(1, values) + + @accounting.insert(create_vmpool_hash) + check_lines(1,2) + + h1 = values[:history].first + sum1 = h1[:retime] - h1[:rstime] + + h2 = values[:history].last + sum2 = ts3 - h2[:rstime] + + warn "* T1 RSTIME1 RETIME1 RSTIME1 T2" + @watch_client.running_time(ts1, ts3).to_i.should eql(sum1 + sum2) + end +end \ No newline at end of file diff --git a/src/acct/test/XVm1His.rb b/src/acct/test/XVm1His.rb new file mode 100644 index 0000000000..1aa11c2d7c --- /dev/null +++ b/src/acct/test/XVm1His.rb @@ -0,0 +1,91 @@ +require 'helper/test_helper.rb' + +describe "X Vm 1 History" do + before(:each) do + clean_db + + @mock_client = MockClient.new + @accounting = OneWatch::Accounting.new(@mock_client) + + @watch_client = AcctClient.new + + @db = WatchHelper::DB + check_lines(0,0) + end + + it "Running testing" do + ts1 = 100 + @accounting.set_mock_timestamp(ts1) + + @accounting.insert(create_vmpool_hash) + check_lines(0,0) + + ts2 = 200 + @accounting.set_mock_timestamp(ts2) + + values = { + :uid => 2, + :gid => 4, + :history => [ + :hid => 6, + :seq => 0, + :pstime => 150, + :petime => 155, + :rstime => 155, + :retime => 0, + :estime => 0, + :eetime => 0, + :reason => 0 + ] + } + + @mock_client.add_vm(1, values) + + @accounting.insert(create_vmpool_hash) + check_lines(1,1) + + history = values[:history].first + sum = ts2 - history[:rstime] + + warn "* T1 RSTIME T2" + @watch_client.running_time(ts1, ts2).to_i.should eql(sum) + + ts3 = 300 + @accounting.set_mock_timestamp(ts3) + + values2 = { + :uid => 2, + :gid => 4, + :history => [ + :hid => 7, + :seq => 0, + :pstime => 220, + :petime => 260, + :rstime => 260, + :retime => 0, + :estime => 0, + :eetime => 0, + :reason => 0 + ] + } + + @mock_client.add_vm(2, values2) + + @accounting.insert(create_vmpool_hash) + check_lines(2,2) + + history1 = values[:history].first + sum1 = ts3 - history1[:rstime] + + history2 = values2[:history].first + sum2 = ts3 - history2[:rstime] + + warn "* T1 RSTIME T2" + @watch_client.running_time(ts1, ts3).to_i.should eql(sum1 + sum2) + @watch_client.running_time(ts1, ts3, :vmid=>1).to_i.should eql(sum1) + @watch_client.running_time(ts1, ts3, :vmid=>2).to_i.should eql(sum2) + @watch_client.running_time(ts1, ts3, :uid=>2).to_i.should eql(sum1 + sum2) + @watch_client.running_time(ts1, ts3, :hid=>6).to_i.should eql(sum1) + @watch_client.running_time(ts1, ts3, :hid=>7).to_i.should eql(sum2) + end +end \ No newline at end of file diff --git a/src/acct/test/fixtures/empty_pool.xml b/src/acct/test/fixtures/empty_pool.xml new file mode 100644 index 0000000000..2a8bcd37c2 --- /dev/null +++ b/src/acct/test/fixtures/empty_pool.xml @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/src/acct/test/fixtures/vm.xml b/src/acct/test/fixtures/vm.xml new file mode 100644 index 0000000000..1560a16029 --- /dev/null +++ b/src/acct/test/fixtures/vm.xml @@ -0,0 +1,46 @@ + + <%= id %> + <%= vm[:uid] ? vm[:uid] : 0 %> + <%= vm[:gid] ? vm[:gid] : 0 %> + <%= vm[:name] ? vm[:uid] : 'pepe' %> + <%= vm[:last_poll] ? vm[:last_poll] : '1309275256' %> + <%= vm[:state] ? vm[:state] : 3 %> + 3 + 1309275252 + 0 + dummy + <%= vm[:memory] ? vm[:memory] : 128 %> + <%= vm[:cpu] ? vm[:cpu] : 1 %> + <%= vm[:net_tx] ? vm[:net_tx] : 0 %> + <%= vm[:net_rx] ? vm[:net_rx] : 0 %> + + <% if history = vm[:history] %> + + <% history.each do |h| %> + + <%= h[:seq] ? h[:seq] : 0 %> + <%= h[:hostname] ? h[:hostname] : "kvxen" %> + /Users/dmolina/trabajo/acctmoni/install/var/ + <%= h[:hid] ? h[:hid] : 0 %> + 1309275256 + 0 + vmm_dummy + tm_dummy + <%= h[:pstime] ? h[:pstime] : 0 %> + <%= h[:petime] ? h[:petime] : 0 %> + <%= h[:rstime] ? h[:rstime] : 0 %> + <%= h[:retime] ? h[:retime] : 0 %> + <%= h[:estime] ? h[:estime] : 0 %> + <%= h[:eetime] ? h[:eetime] : 0 %> + <%= h[:reason] ? h[:reason] : 0 %> + + <% end %> + + <% end %> + \ No newline at end of file diff --git a/src/acct/test/fixtures/vmpool.xml b/src/acct/test/fixtures/vmpool.xml new file mode 100644 index 0000000000..1ff7f5626e --- /dev/null +++ b/src/acct/test/fixtures/vmpool.xml @@ -0,0 +1,49 @@ + + <% vms.each do |id,vm| %> + + <%= id %> + <%= vm[:uid] ? vm[:uid] : 0 %> + <%= vm[:gid] ? vm[:gid] : 0 %> + <%= vm[:name] ? vm[:uid] : 'pepe' %> + <%= vm[:last_poll] ? vm[:last_poll] : '1309275256' %> + <%= vm[:state] ? vm[:state] : 3 %> + 3 + 1309275252 + 0 + dummy + <%= vm[:memory] ? vm[:memory] : 128 %> + <%= vm[:cpu] ? vm[:cpu] : 1 %> + <%= vm[:net_tx] ? vm[:net_tx] : 0 %> + <%= vm[:net_rx] ? vm[:net_rx] : 0 %> + + <% if history = vm[:history] %> + + <% h = history.last %> + + <%= h[:seq] ? h[:seq] : 0 %> + <%= h[:hostname] ? h[:hostname] : "kvxen" %> + /Users/dmolina/trabajo/acctmoni/install/var/ + <%= h[:hid] ? h[:hid] : 0 %> + 1309275256 + 0 + vmm_dummy + tm_dummy + <%= h[:pstime] ? h[:pstime] : 0 %> + <%= h[:petime] ? h[:petime] : 0 %> + <%= h[:rstime] ? h[:rstime] : 0 %> + <%= h[:retime] ? h[:retime] : 0 %> + <%= h[:estime] ? h[:estime] : 0 %> + <%= h[:eetime] ? h[:eetime] : 0 %> + <%= h[:reason] ? h[:reason] : 0 %> + + + <% end %> + + <% end %> + diff --git a/src/acct/test/helper/mock_client.rb b/src/acct/test/helper/mock_client.rb new file mode 100644 index 0000000000..1f04f5c098 --- /dev/null +++ b/src/acct/test/helper/mock_client.rb @@ -0,0 +1,49 @@ +require 'erb' + +FPATH = "./fixtures/" + +class MockClient + def initialize + @vmpool = File.read("./fixtures/empty_pool.xml") + @done_vmpool = File.read("./fixtures/empty_pool.xml") + + @vms = Hash.new + @done_vms = Hash.new + end + + + def call(action, *args) + xmlrpc_action = "one."+action + + case xmlrpc_action + when "one.vm.info" + id = args[0] + vm = @vms[id] + return ERB.new(File.read(FPATH+'vm.xml')).result(binding) + when "one.vmpool.info" + case args[3] + when -1 + return File.read("./fixtures/empty_pool.xml") if @vms.empty? + vms = @vms + return ERB.new(File.read(FPATH+'vmpool.xml')).result(binding) + when 6 then + return File.read("./fixtures/empty_pool.xml") if @done_vms.empty? + vms = @done_vms + return ERB.new(File.read(FPATH+'vmpool.xml')).result(binding) + end + end + end + + def add_vm(id, values) + if values[:state] == 6 + @done_vms[id] = values.clone + else + @vms[id] = values.clone + end + end + + def delete_vm(id) + @vms.delete(id) + @vms_done.delete(id) + end +end \ No newline at end of file diff --git a/src/acct/test/helper/test_helper.rb b/src/acct/test/helper/test_helper.rb new file mode 100644 index 0000000000..eab69fbf94 --- /dev/null +++ b/src/acct/test/helper/test_helper.rb @@ -0,0 +1,71 @@ +require 'rubygems' +require 'sequel' + +ONE_LOCATION = ENV['ONE_LOCATION'] +if !ONE_LOCATION + RUBY_LIB_LOCATION="/usr/lib/one/ruby" +else + RUBY_LIB_LOCATION=ONE_LOCATION+"/lib/ruby" +end + +$: << RUBY_LIB_LOCATION + +require 'OpenNebula' + +$: << './helper' +$: << '.' +$: << '..' + + +require 'examples/acct_client' +require 'watch_client' +require 'mock_client' + +require 'accounting' +require 'monitoring' + +module OneWatch + class Accounting + def set_mock_timestamp(t) + @mock_timestamp = t + end + + def generate_timestamp + @mock_timestamp + end + end + + class Monitoring + def set_mock_timestamp(t) + @mock_timestamp = t + end + + def generate_timestamp + @mock_timestamp + end + end +end + +def create_vmpool_hash + @vm_pool = OpenNebula::VirtualMachinePool.new(@mock_client, -2) + @vm_pool.info + hash = @vm_pool.to_hash +end + +def clean_db + begin + WatchHelper::Register.destroy + WatchHelper::VmDelta.destroy + WatchHelper::VmSample.destroy + WatchHelper::HostSample.destroy + WatchHelper::Vm.destroy + WatchHelper::Host.destroy + rescue Exception => e + warn e.message + end +end + +def check_lines(*args) + @db[:vms].count.should eql(args[0]) + @db[:registers].count.should eql(args[1]) +end diff --git a/src/acct/test/monitoring_spec.rb b/src/acct/test/monitoring_spec.rb new file mode 100644 index 0000000000..f3f7272a17 --- /dev/null +++ b/src/acct/test/monitoring_spec.rb @@ -0,0 +1,102 @@ +require 'helper/test_helper.rb' + +describe "1 Vm 1 10 steps" do + before(:each) do + clean_db + + @mock_client = MockClient.new + @monitoring = OneWatch::VmMonitoring.new + + @watch_client = OneWatchClient::WatchClient.new + + @db = WatchHelper::DB + @db[:vms].count.should eql(0) + end + + it "CPU testing" do + ts1 = 100 + @monitoring.set_mock_timestamp(ts1) + + @monitoring.insert(create_vmpool_hash) + @db[:vms].count.should eql(0) + + 10.times { |i| + ts2 = 200+100*i + @monitoring.set_mock_timestamp(ts2) + + values = { + :cpu => 80+i, + :memory => 122+i, + :net_tx => 200+i, + :net_rx => 134+i, + :last_poll => 1309275256+i, + :uid => 2, + :gid => 4, + :history => [ + :hid => 7, + :pstime => 150, + :petime => 0, + :rstime => 0, + :retime => 0, + :estime => 0, + :eetime => 0, + :reason => 0 + ] + } + + @mock_client.add_vm(1, values) + + @monitoring.insert(create_vmpool_hash) + @db[:vms].count.should eql(1) + @db[:vm_samples].count.should eql(1+i > 5 ? 5 : 1+i) + + @watch_client.vm_monitoring(1, ['cpu', 'net_tx']) + + @watch_client.vm_total + } + end + + it "Total testing" do + ts1 = 100 + @monitoring.set_mock_timestamp(ts1) + + @monitoring.insert(create_vmpool_hash) + @db[:vms].count.should eql(0) + + 10.times { |i| + ts2 = 200+100*i + @monitoring.set_mock_timestamp(ts2) + + values = { + :cpu => 80+i, + :memory => 122+i, + :net_tx => 200+i, + :net_rx => 134+i, + :state => 7, + :last_poll => 1309275256+i, + :uid => 2, + :gid => 4, + :history => [ + :hid => 7, + :pstime => 150, + :petime => 0, + :rstime => 0, + :retime => 0, + :estime => 0, + :eetime => 0, + :reason => 0 + ] + } + + values[:state] = 7 + @mock_client.add_vm(i+100, values) + values[:state] = 3 + @mock_client.add_vm(i+10, values) + + @monitoring.insert(create_vmpool_hash) + + @db[:vm_samples].count + total = @watch_client.vm_total([:total, :error, :active]) + } + end +end \ No newline at end of file diff --git a/src/acct/watch_client.rb b/src/acct/watch_client.rb new file mode 100644 index 0000000000..5710b83a98 --- /dev/null +++ b/src/acct/watch_client.rb @@ -0,0 +1,131 @@ +module OneWatchClient + require 'acct/watch_helper' + + class WatchClient + def vm_monitoring(id, opts=[]) + if resource = WatchHelper::Vm[id] + resource_monitoring( + resource, + "VM", + WatchHelper::VM_SAMPLE, + opts + ) + else + return nil + end + end + + def host_monitoring(id, opts=[]) + if resource = WatchHelper::Host[id] + resource_monitoring( + resource, + "HOST", + WatchHelper::HOST_SAMPLE, + opts + ) + else + return nil + end + end + + def vm_total(opts=[]) + total_monitoring( + WatchHelper::VmSample, + "VM", + WatchHelper::VM_SAMPLE, + opts + ) + end + + def host_total(opts=[]) + total_monitoring( + WatchHelper::HostSample, + "HOST", + WatchHelper::HOST_SAMPLE, + opts + ) + end + + private + + def total_monitoring(rsql, kind, allowed_samples, monitoring_resources) + hash = Hash.new + hash[:resource] = "#{kind.upcase}_POOL" + + mon = Hash.new + monitoring_resources.each { |opt| + opt = opt.to_sym + if allowed_samples.has_key?(opt) + mon[opt] = sum_monitoring(rsql, kind, opt) + elsif [:total, :active, :error].include?(opt) + mon[opt] = count_monitoring(rsql, opt) + end + } + + hash[:monitoring] = mon + + hash + end + + def sum_monitoring(rsql, kind, mr) + a = Array.new + + WatchHelper::DB.fetch( + "SELECT last_poll,sum(u#{mr}) AS sum_#{mr} FROM " << + "(SELECT last_poll, max(#{mr}) AS u#{mr} " << + "FROM #{kind.downcase}_samples " << + "GROUP BY #{kind.downcase}_id, last_poll) " << + "GROUP BY last_poll;" + ) do |row| + if row[:last_poll] && row[:last_poll] != 0 + a << [row[:last_poll], row["sum_#{mr}"].to_i] + end + end + + a + end + + def count_monitoring(rsql, opt) + resources = case opt + when :total then rsql + when :active then rsql.active + when :error then rsql.error + else return nil + end + + a = Array.new + resources.group_and_count(:timestamp).collect { |row| + a << [row[:timestamp], row[:count]] + } + + a + end + + def resource_monitoring(rsql, kind, allowed_sample, monitoring_resources) + hash = Hash.new + hash[:resource] = kind + hash[:id] = rsql.id + + mon = Hash.new + monitoring_resources.each { |mr| + if allowed_sample.has_key?(mr.to_sym) + mon[mr] = Array.new + else + monitoring_resources.delete(mr) + end + } + + rsql.samples_dataset.map { |sample| + monitoring_resources.each { |mr| + if sample.last_poll && sample.last_poll != 0 + mon[mr] << [sample.last_poll, sample.send(mr.to_sym)] + end + } + } + + hash[:monitoring] = mon + + hash + end + end +end \ No newline at end of file diff --git a/src/acct/watch_helper.rb b/src/acct/watch_helper.rb new file mode 100644 index 0000000000..4cc5ab9c98 --- /dev/null +++ b/src/acct/watch_helper.rb @@ -0,0 +1,402 @@ +module WatchHelper + require 'sequel' + require 'yaml' + + ONE_LOCATION=ENV["ONE_LOCATION"] + + if !ONE_LOCATION + ACCTD_CONF="/etc/one/acctd.conf" + else + ACCTD_CONF=ONE_LOCATION+"/etc/acctd.conf" + end + + CONF = YAML.load_file(ACCTD_CONF) + + DB = Sequel.connect(CONF[:DB]) + VM_DELTA = { + :net_rx => { + :type => Integer, + :path => 'NET_RX' + }, + :net_tx => { + :type => Integer, + :path => 'NET_TX' + } + } + + VM_SAMPLE = { + :cpu => { + :type => Integer, + :path => 'CPU' + }, + :memory => { + :type => Integer, + :path => 'MEMORY' + }, + :net_tx => { + :type => Integer, + :path => 'NET_TX' + }, + :net_rx => { + :type => Integer, + :path => 'NET_RX' + } + } + + HOST_SAMPLE = { + :disk_usage => { + :type => Integer, + :path => 'DISK_USAGE' + }, + :mem_usage => { + :type => Integer, + :path => 'MEM_USAGE' + }, + :cpu_usage => { + :type => Integer, + :path => 'CPU_USAGE' + }, + :max_disk => { + :type => Integer, + :path => 'MAX_DISK' + }, + :max_mem => { + :type => Integer, + :path => 'MAX_MEM' + }, + :max_cpu => { + :type => Integer, + :path => 'MAX_CPU' + }, + :free_disk => { + :type => Integer, + :path => 'FREE_DISK' + }, + :free_mem => { + :type => Integer, + :path => 'FREE_MEM' + }, + :free_cpu => { + :type => Integer, + :path => 'FREE_CPU' + }, + :used_disk => { + :type => Integer, + :path => 'USED_DISK' + }, + :used_mem => { + :type => Integer, + :path => 'USED_MEM' + }, + :used_cpu => { + :type => Integer, + :path => 'USED_CPU' + }, + :rvms => { + :type => Integer, + :path => 'RUNNING_VMS' + } + } + + def self.get_config(*params) + conf = CONF + while param = params.shift + conf = conf[param] + break if conf.nil? + end + conf + end + + def self.bootstrap + DB.create_table? :vms do + Integer :id, :primary_key=>true + String :name + Integer :uid + Integer :gid + Integer :mem + Integer :cpu + Integer :vcpu + Integer :stime + Integer :etime + end + + DB.create_table? :hosts do + Integer :id, :primary_key=>true + String :name + String :im_mad + String :vm_mad + String :tm_mad + end + + DB.create_table? :vm_samples do + foreign_key :vm_id, :vms, :key=>:id + Integer :state + Integer :lcm_state + Integer :last_poll + Integer :timestamp + + VM_SAMPLE.each { |key,value| + column key, value[:type] + } + + primary_key [:vm_id, :timestamp] + end + + DB.create_table? :host_samples do + foreign_key :host_id, :hosts, :key=>:id + Integer :last_poll + Integer :timestamp + Integer :state + + HOST_SAMPLE.each { |key,value| + column key, value[:type] + } + + primary_key [:host_id, :timestamp] + end + + DB.create_table? :registers do + foreign_key :vm_id, :vms, :key=>:id + Integer :hid + String :hostname + Integer :seq + Integer :pstime + Integer :petime + Integer :rstime + Integer :retime + Integer :estime + Integer :eetime + Integer :reason + + primary_key [:vm_id, :seq] + end + + DB.create_table? :vm_deltas do + foreign_key :vm_id, :vms, :key=>:id + Integer :timestamp + Integer :ptimestamp + + VM_DELTA.each { |key,value| + column key, value[:type] + } + + primary_key [:vm_id, :timestamp] + end + end + + self.bootstrap + + class VmSample < Sequel::Model + unrestrict_primary_key + + many_to_one :vm + + def self.active + self.filter(:state=>3) + end + + def self.error + self.filter(:state=>7) + end + end + + class HostSample < Sequel::Model + unrestrict_primary_key + + many_to_one :host + + def self.active + self.filter('state < 3') + end + + def self.error + self.filter(:state=>3) + end + end + + class Register < Sequel::Model + unrestrict_primary_key + + many_to_one :vm + + def update_from_history(history) + self.seq = history['SEQ'] + self.hostname = history['HOSTNAME'] + self.hid = history['HID'] + self.pstime = history['PSTIME'] + self.petime = history['PETIME'] + self.rstime = history['RSTIME'] + self.retime = history['RETIME'] + self.estime = history['ESTIME'] + self.eetime = history['EETIME'] + self.reason = history['REASON'] + + self.save + end + end + + class VmDelta < Sequel::Model + unrestrict_primary_key + + many_to_one :vm + end + + class Vm < Sequel::Model + unrestrict_primary_key + + # Accounting + one_to_many :registers, :order=>:seq + one_to_many :deltas, :order=>:timestamp, :class=>VmDelta + + # Monitoring + one_to_many :samples, :order=>:timestamp, :class=>VmSample + + @@samples_cache = [] + @@deltas_cache = [] + + @@vm_window_size = WatchHelper::get_config( + :VM_MONITORING, + :WINDOW_SIZE + ) + + def self.info(vm) + Vm.find_or_create(:id=>vm['ID']) { |v| + v.name = vm['NAME'] + v.uid = vm['UID'].to_i + v.gid = vm['GID'].to_i + v.mem = vm['MEMORY'].to_i + v.cpu = vm['CPU'].to_i + v.vcpu = vm['VCPU'].to_i + v.stime = vm['STIME'].to_i + v.etime = vm['ETIME'].to_i + } + end + + def add_register_from_resource(history) + self.add_register( + :seq => history['SEQ'], + :hostname => history['HOSTNAME'], + :hid => history['HID'], + :pstime => history['PSTIME'], + :petime => history['PETIME'], + :rstime => history['RSTIME'], + :retime => history['RETIME'], + :estime => history['ESTIME'], + :eetime => history['EETIME'], + :reason => history['REASON'] + ) + end + + def add_sample_from_resource(vm, timestamp) + hash = { + :vm_id => vm['ID'], + :timestamp => timestamp, + :last_poll => vm['LAST_POLL'], + :state => vm['STATE'], + :lcm_state => vm['LCM_STATE'] + } + + VM_SAMPLE.each { |key,value| + hash[key] = vm[value[:path]] + } + + @@samples_cache << hash + end + + def add_delta_from_resource(vm, timestamp) + hash = Hash.new + + hash[:vm_id] = vm['ID'] + hash[:timestamp] = timestamp + + if last_delta = self.deltas.first + hash[:ptimestamp] = last_delta.send(:timestamp) + + VM_DELTA.each { |key,value| + old_value = last_delta.send("#{key}".to_sym) + new_value = vm[value[:path]].to_i + + if old_value > new_value + hash[key] = new_value + else + hash[key] = new_value - old_value + end + } + else + hash[:ptimestamp] = 0 + + VM_DELTA.each { |key,value| + hash[key] = vm[value[:path]] + } + end + + @@deltas_cache << hash + end + + def self.flush + VmDelta.multi_insert(@@deltas_cache) + VmSample.multi_insert(@@samples_cache) + + Vm.each { |vm| + if vm.samples.count > @@vm_window_size + vm.samples.last.delete + end + } + + @@samples_cache = [] + @@deltas_cache = [] + end + end + + class Host < Sequel::Model + unrestrict_primary_key + + # Monitoring + one_to_many :samples, :order=>:timestamp, :class=>HostSample + + @@samples_cache = [] + + @@host_window_size = WatchHelper::get_config( + :HOST_MONITORING, + :WINDOW_SIZE + ) + + + def self.info(host) + Host.find_or_create(:id=>host['ID']) { |h| + h.name = host['NAME'] + h.im_mad = host['IM_MAD'] + h.vm_mad = host['VM_MAD'] + h.tm_mad = host['TM_MAD'] + } + end + + def add_sample_from_resource(host, timestamp) + hash = { + :host_id => host['ID'], + :timestamp => timestamp, + :last_poll => host['LAST_MON_TIME'], + :state => host['STATE'], + } + + host_share = host['HOST_SHARE'] + HOST_SAMPLE.each { |key,value| + hash[key] = host_share[value[:path]] + } + + @@samples_cache << hash + end + + def self.flush + HostSample.multi_insert(@@samples_cache) + + Host.all.each { |host| + if host.samples.count > @@host_window_size + host.samples.first.delete + end + } + + @@samples_cache = [] + end + end +end diff --git a/src/cli/one_helper.rb b/src/cli/one_helper.rb index 1d674fbe95..9920c2eba7 100644 --- a/src/cli/one_helper.rb +++ b/src/cli/one_helper.rb @@ -314,7 +314,7 @@ EOT end def OpenNebulaHelper.name_to_id(name, poolname, user_flag=-2) - return 0, name if name.match(/^[0123456789]+$/) + return 0, name.to_i if name.match(/^[0123456789]+$/) client = OpenNebula::Client.new # TBD user_flag diff --git a/src/sunstone/models/SunstoneServer.rb b/src/sunstone/models/SunstoneServer.rb index 9e56959a3f..f1cec51f60 100644 --- a/src/sunstone/models/SunstoneServer.rb +++ b/src/sunstone/models/SunstoneServer.rb @@ -17,7 +17,7 @@ require 'OpenNebulaJSON' include OpenNebulaJSON -require 'OneMonitorClient' +require 'acct/watch_client' class SunstoneServer def initialize(username, password) @@ -288,22 +288,34 @@ class SunstoneServer # ############################################################################ - def get_log(params) - resource = params[:resource] - id = params[:id] - id = "global" unless id - columns = params['monitor_resources'].split(',') - history_length = params['history_length'] + def get_monitoring(id, resource, monitor_resources) + watch_client = OneWatchClient::WatchClient.new + columns = monitor_resources.split(',') - log_file_folder = case resource - when "vm","VM" - VM_LOG_FOLDER - when "host","HOST" - HOST_LOG_FOLDER - end + rc = case resource + when "vm","VM" + if id + watch_client.vm_monitoring(id, columns) + else + watch_client.vm_total(columns) + end + when "host","HOST" + if id + watch_client.host_monitoring(id, columns) + else + watch_client.host_total(columns) + end + else + error = Error.new("Monitoring not supported for this resource: #{resource}") + return [200, error.to_json] + end - monitor_client = OneMonitorClient.new(id,log_file_folder) - return monitor_client.get_data_for_id(id,columns,history_length).to_json + if rc.nil? + error = Error.new("There is no monitoring information for #{resource} #{id}") + return [500, error.to_json] + end + + return [200, rc.to_json] end ############################################################################ diff --git a/src/sunstone/public/js/plugins/dashboard-tab.js b/src/sunstone/public/js/plugins/dashboard-tab.js index 08914d197b..72270168be 100644 --- a/src/sunstone/public/js/plugins/dashboard-tab.js +++ b/src/sunstone/public/js/plugins/dashboard-tab.js @@ -167,30 +167,33 @@ Sunstone.addMainTab('dashboard_tab',dashboard_tab); function plot_global_graph(data,info){ var id = info.title; - var labels_arr = info.monitor_resources.split(','); + var monitoring = data.monitoring; var serie; var series = []; var width = ($(window).width()-129)*45/100; + var mon_count = 0; $('#'+id).html('
'); - for (var i = 0; i< labels_arr.length; i++) { + for (var label in monitoring) { serie = { - label: labels_arr[i], - data: data[i] + label: label, + data: monitoring[label] }; series.push(serie); + mon_count++; }; var options = { legend : { show : true, - noColumns: labels_arr.length, + noColumns: mon_count, container: $('#'+id+'_legend') }, xaxis : { - mode: "time", - timeformat: "%h:%M" + tickFormatter: function(val,axis){ + return pretty_time_axis(val); + }, }, yaxis : { labelWidth: 40 } } diff --git a/src/sunstone/public/js/sunstone-util.js b/src/sunstone/public/js/sunstone-util.js index bfed8e919d..83acf85918 100644 --- a/src/sunstone/public/js/sunstone-util.js +++ b/src/sunstone/public/js/sunstone-util.js @@ -46,6 +46,20 @@ function pretty_time(time_seconds) return hour + ":" + mins +":" + secs + " " + month + "/" + day + "/" + year; } +function pretty_time_axis(time){ + var d = new Date(); + d.setTime(time*1000); + + var secs = pad(d.getSeconds(),2); + var hour = pad(d.getHours(),2); + var mins = pad(d.getMinutes(),2); + var day = pad(d.getDate(),2); + var month = pad(d.getMonth()+1,2); //getMonths returns 0-11 + var year = d.getFullYear(); + + return hour + ":" + mins + ":" + secs;// + " " + month + "/" + day; +} + //returns a human readable size in Kilo, Mega, Giga or Tera bytes function humanize_size(value) { if (typeof(value) === "undefined") { @@ -518,27 +532,31 @@ function plot_graph(data,context,id_prefix,info){ var labels = info.monitor_resources; var humanize = info.humanize_figures ? humanize_size : function(val){ return val }; - var labels_arr = labels.split(','); var id_suffix = labels.replace(/,/g,'_'); + var monitoring = data.monitoring var series = []; - var serie = null; + var serie; + var mon_count = 0; - for (var i = 0; i< labels_arr.length; i++) { + for (var label in monitoring) { serie = { - label: labels_arr[i], - data: data[i] + label: label, + data: monitoring[label] }; series.push(serie); + mon_count++; }; var options = { legend : { show : true, - noColumns: labels_arr.length, + noColumns: mon_count++, container: $('#legend_'+id_suffix) }, - xaxis : { mode: "time", - timeformat: "%h:%M" - }, + xaxis : { + tickFormatter: function(val,axis){ + return pretty_time_axis(val); + }, + }, yaxis : { labelWidth: 40, tickFormatter: function(val, axis) { return humanize(val); diff --git a/src/sunstone/sunstone-server.rb b/src/sunstone/sunstone-server.rb index 010b62d64f..54fe8c4dd9 100755 --- a/src/sunstone/sunstone-server.rb +++ b/src/sunstone/sunstone-server.rb @@ -178,11 +178,19 @@ end ############################################################################## get '/:resource/monitor' do - @SunstoneServer.get_log(params) + @SunstoneServer.get_monitoring( + nil, + params[:resource], + params[:monitor_resources] + ) end get '/:resource/:id/monitor' do - @SunstoneServer.get_log(params) + @SunstoneServer.get_monitoring( + params[:id], + params[:resource], + params[:monitor_resources] + ) end