Class: NodeHostProperty

Inherits:

Object

Object
NodeHostProperty

show all

Defined in:: lib/gui/node_host_property.rb

Instance Method Summary collapse

Constructor Details

#initialize(node) ⇒ `NodeHostProperty`

Returns a new instance of NodeHostProperty.

# File 'lib/gui/node_host_property.rb', line 1456

def initialize (node)

@color_style = [$red, $orange, $yellow, $blue]

window=Gtk::Window.new
#we need window to be a class variable to be accessible from account_frame sub error window
@window=window
window.set_transient_for($win)
window.set_title("Node property of "+node.ip+"/#{node.netmask}")
window.set_size_request(450, 450)
window.set_modal(true)
vboxb = Gtk::VBox::new
window.add vboxb
vboxb.show	

notebook = Gtk::Notebook::new()
notebook.set_tab_pos(Gtk::POS_TOP)
vboxb.add notebook
notebook.show

################################ status tab #########

frame = Gtk::Frame::new
frame.border_width=10
frame.set_size_request(300, 290)
frame.show

vbox = Gtk::VBox::new(false,2)
vbox.show
frame.add vbox 

frame_st=Gtk::Frame.new("General")
frame_st.border_width=10
table_st = Gtk::Table.new(1,2,false)
table_st.show
label_status = Gtk::Label.new "Current"
label_status.show
entry_status = Gtk::Entry.new
tstyle=Gtk::Style.new
rgb=hexa_to_rgb_color($status_color[$status_value[node.status]])
tstyle.set_base(Gtk::STATE_NORMAL, rgb.red, rgb.green, rgb.blue)
entry_status.set_style(tstyle)
entry_status.set_text($status[$status_value[node.status]])
entry_status.set_size_request(100, -1)
entry_status.set_xalign(0.5);
entry_status.set_editable false
entry_status.show
bbox=Gtk::HButtonBox.new
bbox.show
bbox.add entry_status
table_st.attach(label_status,0,1,0,1)
table_st.attach(bbox,1,2,0,1)
frame_st.add table_st
frame_st.show
vbox.add frame_st

frame_dt=Gtk::Frame.new("Details")
frame_dt.border_width=10
table = Gtk::Table.new(8,2,false)
table.show

label_avail = Gtk::Label.new "Availability"
label_avail.show
entry_avail = Gtk::Entry.new
tstyle=Gtk::Style.new
rgb=nil
	rgb=hexa_to_rgb_color($status_color[$status_value.index(node.avail_sev)])
entry_avail.set_text($status[$status_value.index(node.avail_sev)])
tstyle.set_base(Gtk::STATE_NORMAL, rgb.red, rgb.green, rgb.blue)
entry_avail.set_style(tstyle)
entry_avail.set_size_request(100, -1)
entry_avail.set_xalign(0.5);
entry_avail.set_editable false
entry_avail.show
bbox=Gtk::HButtonBox.new
bbox.show
bbox.add entry_avail
table.attach(label_avail,0,1,0,1)
table.attach(bbox,1,2,0,1)
  
label_service = Gtk::Label.new "Service"
label_service.show
entry_service = Gtk::Entry.new
tstyle=Gtk::Style.new
rgb=nil
if $config.port_mon
 rgb=hexa_to_rgb_color($status_color[$status_value.index(node.service_sev)])
 entry_service.set_text($status[$status_value.index(node.service_sev)])
else
 rgb=hexa_to_rgb_color($status_color[$status_value.index(UNMANAGED)])
 entry_service.set_text($status[$status_value.index(UNMANAGED)])
end
tstyle.set_base(Gtk::STATE_NORMAL, rgb.red, rgb.green, rgb.blue)
entry_service.set_style(tstyle)
entry_service.set_size_request(100, -1)
entry_service.set_xalign(0.5);
entry_service.set_editable false
entry_service.show
bbox=Gtk::HButtonBox.new
bbox.show
bbox.add entry_service
table.attach(label_service,0,1,1,2)
table.attach(bbox,1,2,1,2)

label_snmp = Gtk::Label.new "SNMP"
label_snmp.show
entry_snmp = Gtk::Entry.new
tstyle=Gtk::Style.new
rgb=nil
if $config.snmp_mon
 rgb=hexa_to_rgb_color($status_color[$status_value.index(node.snmp_sev)])
 entry_snmp.set_text($status[$status_value.index(node.snmp_sev)])
	else
 rgb=hexa_to_rgb_color($status_color[$status_value.index(UNMANAGED)])
 entry_snmp.set_text($status[$status_value.index(UNMANAGED)])
	end
tstyle.set_base(Gtk::STATE_NORMAL, rgb.red, rgb.green, rgb.blue)
entry_snmp.set_style(tstyle)

entry_snmp.set_size_request(100, -1)
entry_snmp.set_xalign(0.5);
entry_snmp.set_editable false
entry_snmp.show
bbox=Gtk::HButtonBox.new
bbox.show
bbox.add entry_snmp
table.attach(label_snmp,0,1,2,3)
table.attach(bbox,1,2,2,3)

label_wmi = Gtk::Label.new "WMI"
label_wmi.show
entry_wmi = Gtk::Entry.new
tstyle=Gtk::Style.new
rgb=nil
if $config.wmi_mon
 rgb=hexa_to_rgb_color($status_color[$status_value.index(node.wmi_sev)])
 entry_wmi.set_text($status[$status_value.index(node.wmi_sev)])
	else
 rgb=hexa_to_rgb_color($status_color[$status_value.index(UNMANAGED)])
 entry_wmi.set_text($status[$status_value.index(UNMANAGED)])
	end
tstyle.set_base(Gtk::STATE_NORMAL, rgb.red, rgb.green, rgb.blue)
entry_wmi.set_style(tstyle)

entry_wmi.set_size_request(100, -1)
entry_wmi.set_xalign(0.5);
entry_wmi.set_editable false
entry_wmi.show
bbox=Gtk::HButtonBox.new
bbox.show
bbox.add entry_wmi
table.attach(label_wmi,0,1,3,4)
table.attach(bbox,1,2,3,4)

label_jmx = Gtk::Label.new "JMX"
label_jmx.show
entry_jmx = Gtk::Entry.new
tstyle=Gtk::Style.new
rgb=nil
if $config.jmx_mon
 rgb=hexa_to_rgb_color($status_color[$status_value.index(node.jmx_sev)])
 entry_jmx.set_text($status[$status_value.index(node.jmx_sev)])
	else
 rgb=hexa_to_rgb_color($status_color[$status_value.index(UNMANAGED)])
 entry_jmx.set_text($status[$status_value.index(UNMANAGED)])
	end
tstyle.set_base(Gtk::STATE_NORMAL, rgb.red, rgb.green, rgb.blue)
entry_jmx.set_style(tstyle)

entry_jmx.set_size_request(100, -1)
entry_jmx.set_xalign(0.5);
entry_jmx.set_editable false
entry_jmx.show
bbox=Gtk::HButtonBox.new
bbox.show
bbox.add entry_jmx
table.attach(label_jmx,0,1,4,5)
table.attach(bbox,1,2,4,5)

label_custom = Gtk::Label.new "Custom"
label_custom.show
entry_custom = Gtk::Entry.new
tstyle=Gtk::Style.new
	rgb=nil
	if $config.custom_mon
 rgb=hexa_to_rgb_color($status_color[$status_value.index(node.custom_sev)])
 entry_custom.set_text($status[$status_value.index(node.custom_sev)])
	else
 rgb=hexa_to_rgb_color($status_color[$status_value.index(UNMANAGED)])
 entry_custom.set_text($status[$status_value.index(UNMANAGED)])
	end
tstyle.set_base(Gtk::STATE_NORMAL, rgb.red, rgb.green, rgb.blue)
entry_custom.set_style(tstyle)

entry_custom.set_size_request(100, -1)
entry_custom.set_xalign(0.5)
entry_custom.set_editable false
entry_custom.show
bbox=Gtk::HButtonBox.new
bbox.show
bbox.add entry_custom
table.attach(label_custom,0,1,5,6)
table.attach(bbox,1,2,5,6)

label_syslog = Gtk::Label.new "Syslog"
label_syslog.show
entry_syslog = Gtk::Entry.new
tstyle=Gtk::Style.new
	rgb=nil
	if $config.syslog_mon
 rgb=hexa_to_rgb_color($status_color[$status_value.index(node.syslog_sev)])
 entry_syslog.set_text($status[$status_value.index(node.syslog_sev)])
	else
 rgb=hexa_to_rgb_color($status_color[$status_value.index(UNMANAGED)])
 entry_syslog.set_text($status[$status_value.index(UNMANAGED)])
	end
tstyle.set_base(Gtk::STATE_NORMAL, rgb.red, rgb.green, rgb.blue)
entry_syslog.set_style(tstyle)
entry_syslog.set_size_request(100, -1)
entry_syslog.set_xalign(0.5)
entry_syslog.set_editable false
entry_syslog.show
bbox=Gtk::HButtonBox.new
bbox.show
bbox.add entry_syslog
table.attach(label_syslog,0,1,6,7)
table.attach(bbox,1,2,6,7)

label_trap = Gtk::Label.new "SNMP Trap"
label_trap.show
entry_trap = Gtk::Entry.new
tstyle=Gtk::Style.new
	rgb=nil
	if $config.snmptrap_mon
 rgb=hexa_to_rgb_color($status_color[$status_value.index(node.trap_sev)])
 entry_trap.set_text($status[$status_value.index(node.trap_sev)])
	else
 rgb=hexa_to_rgb_color($status_color[$status_value.index(UNMANAGED)])
 entry_trap.set_text($status[$status_value.index(UNMANAGED)])
	end
tstyle.set_base(Gtk::STATE_NORMAL, rgb.red, rgb.green, rgb.blue)
entry_trap.set_style(tstyle)
entry_trap.set_size_request(100, -1)
entry_trap.set_xalign(0.5)
entry_trap.set_editable false
entry_trap.show
bbox=Gtk::HButtonBox.new
bbox.show
bbox.add entry_trap
table.attach(label_trap,0,1,7,8)
table.attach(bbox,1,2,7,8)

frame_dt.add table
frame_dt.show
vbox.add frame_dt

#update node sev periodically
refresh_node_sev_display=Thread.new {
	while (window != nil) do
  sleep(10)
  begin
  rgb=hexa_to_rgb_color($status_color[$status_value[node.status]])
  Gtk.thread_protect do
  tstyle=Gtk::Style.new
  tstyle.set_base(Gtk::STATE_NORMAL, rgb.red, rgb.green, rgb.blue)
  entry_status.set_style(tstyle)
  entry_status.set_text($status[$status_value[node.status]])

    rgb=nil
	rgb=hexa_to_rgb_color($status_color[$status_value.index(node.avail_sev)])
	entry_avail.set_text($status[$status_value.index(node.avail_sev)])	
  tstyle=Gtk::Style.new
  tstyle.set_base(Gtk::STATE_NORMAL, rgb.red, rgb.green, rgb.blue)
  entry_avail.set_style(tstyle)
    
    rgb=nil
	if $config.port_mon
	  rgb=hexa_to_rgb_color($status_color[$status_value.index(node.service_sev)])
	  entry_service.set_text($status[$status_value.index(node.service_sev)])	
	else
	   rgb=hexa_to_rgb_color($status_color[$status_value.index(UNMANAGED)])
	   entry_service.set_text($status[$status_value.index(UNMANAGED)])
	end
  tstyle=Gtk::Style.new
  tstyle.set_base(Gtk::STATE_NORMAL, rgb.red, rgb.green, rgb.blue)
  entry_service.set_style(tstyle)
	
  rgb=nil
  if $config.snmp_mon || $config.wmi_mon
  	rgb=hexa_to_rgb_color($status_color[$status_value.index(node.snmp_sev)])
  	entry_snmp.set_text($status[$status_value.index(node.snmp_sev)])
  else
  	rgb=hexa_to_rgb_color($status_color[$status_value.index(UNMANAGED)])
  	entry_snmp.set_text($status[$status_value.index(UNMANAGED)])
  end
  tstyle=Gtk::Style.new
  tstyle.set_base(Gtk::STATE_NORMAL, rgb.red, rgb.green, rgb.blue)
  entry_snmp.set_style(tstyle)

  rgb=nil
  if $config.wmi_mon
  	rgb=hexa_to_rgb_color($status_color[$status_value.index(node.wmi_sev)])
  	entry_wmi.set_text($status[$status_value.index(node.wmi_sev)])
  else
  	rgb=hexa_to_rgb_color($status_color[$status_value.index(UNMANAGED)])
  	entry_wmi.set_text($status[$status_value.index(UNMANAGED)])
  end
  tstyle=Gtk::Style.new
  tstyle.set_base(Gtk::STATE_NORMAL, rgb.red, rgb.green, rgb.blue)
  entry_wmi.set_style(tstyle)      
    
  rgb=nil
  if $config.jmx_mon
  	rgb=hexa_to_rgb_color($status_color[$status_value.index(node.jmx_sev)])
  	entry_jmx.set_text($status[$status_value.index(node.jmx_sev)])
  else
  	rgb=hexa_to_rgb_color($status_color[$status_value.index(UNMANAGED)])
  	entry_jmx.set_text($status[$status_value.index(UNMANAGED)])
  end
  tstyle=Gtk::Style.new
  tstyle.set_base(Gtk::STATE_NORMAL, rgb.red, rgb.green, rgb.blue)
  entry_jmx.set_style(tstyle)
    
  rgb=nil
	if $config.custom_mon
  		rgb=hexa_to_rgb_color($status_color[$status_value.index(node.custom_sev)])
 	 	entry_custom.set_text($status[$status_value.index(node.custom_sev)])
	else
	  rgb=hexa_to_rgb_color($status_color[$status_value.index(UNMANAGED)])
	  entry_custom.set_text($status[$status_value.index(UNMANAGED)])
	end
  tstyle=Gtk::Style.new
  tstyle.set_base(Gtk::STATE_NORMAL, rgb.red, rgb.green, rgb.blue)
  entry_custom.set_style(tstyle)
    
    rgb=nil
	if $config.syslog_mon
  		rgb=hexa_to_rgb_color($status_color[$status_value.index(node.syslog_sev)])
 	 	entry_syslog.set_text($status[$status_value.index(node.syslog_sev)])
	else
	  rgb=hexa_to_rgb_color($status_color[$status_value.index(UNMANAGED)])
	  entry_syslog.set_text($status[$status_value.index(UNMANAGED)])
	end
  tstyle=Gtk::Style.new
  tstyle.set_base(Gtk::STATE_NORMAL, rgb.red, rgb.green, rgb.blue)
  entry_syslog.set_style(tstyle)      

	rgb=nil
	if $config.snmptrap_mon
 		rgb=hexa_to_rgb_color($status_color[$status_value.index(node.trap_sev)])
  		entry_trap.set_text($status[$status_value.index(node.trap_sev)])
	else
	  rgb=hexa_to_rgb_color($status_color[$status_value.index(UNMANAGED)])
	  entry_trap.set_text($status[$status_value.index(UNMANAGED)])
	end
  tstyle=Gtk::Style.new
  tstyle.set_base(Gtk::STATE_NORMAL, rgb.red, rgb.green, rgb.blue)
  entry_trap.set_style(tstyle)
  end
  rescue Exception => msg
	$log.debug("Exception in refresh_node_sev_display for #{node.ip}: #{msg}")
end
	end
}

	hbox = Gtk::HBox.new(FALSE, 1)
	hbox.add Gtk::Image.new(Gtk::Stock::DIALOG_WARNING, Gtk::IconSize::MENU)
	hbox.add Gtk::Label::new("Status")
	hbox.show_all
	notebook.append_page frame, hbox

  window.signal_connect("key_press_event") {|w,e|
  if e.keyval == Gdk::Keyval::GDK_Escape
#we rollback here the account from the db to the @account hash
node.init_account_from_db()
Thread.kill(@scan_port_th) unless @scan_port_th == nil
Gtk.thread_flush
Thread.kill(refresh_node_sev_display)
Gtk.thread_flush
window.destroy
  end
}

#########################################################################

#  frame = Gtk::Frame::new
#  frame.border_width=10
#  frame.show

notebook_info = Gtk::Notebook::new()
notebook_info.show

frame_stored = Gtk::Frame::new
frame_stored.border_width=10
frame_stored.set_size_request(300, 290)
frame_stored.show

table = Gtk::Table.new(10,2,false)
table.show

vbox = Gtk::VBox.new
vbox.show
frame_stored.add vbox
vbox.add table

label_icon = Gtk::Label.new "Icon"
label_icon.show
entry_type =  Gtk::ImageComboList.new("type", "#{node.type}")
entry_type.set_size_request(200, -1)
entry_type.show

bbox=Gtk::HButtonBox.new
bbox.show
bbox.add entry_type

table.attach(label_icon,0,1,0,1)
table.attach(bbox,1,2,0,1)

label_xy = Gtk::Label.new "X:Y"
label_xy.show
entry_x = Gtk::Entry.new
entry_x.set_editable false  
entry_x.set_text "#{node.x.to_i}"
entry_x.set_size_request(96, -1)
entry_x.show
bbox=Gtk::HButtonBox.new
bbox.set_layout_style Gtk::ButtonBox::EDGE
bbox.show
bbox.add entry_x
table.attach(label_xy,0,1,1,2)

entry_y = Gtk::Entry.new
entry_y.set_editable false
entry_y.set_text "#{node.y.to_i}"
entry_y.set_size_request(96, -1)
entry_y.show

bbox.add entry_y

table.attach(bbox,1,2,1,2,Gtk::EXPAND)

label_ip = Gtk::Label.new "IP"
label_ip.show
entry_ip = Gtk::Entry.new
entry_ip.set_editable false
entry_ip.set_text(node.ip)
entry_ip.set_size_request(200, -1)
entry_ip.show
bbox=Gtk::HButtonBox.new
bbox.show
bbox.add entry_ip

table.attach(label_ip,0,1,2,3)
table.attach(bbox,1,2,2,3)

label_mask = Gtk::Label.new "Mask"
label_mask.show
entry_mask = Gtk::Entry.new
entry_mask.set_text node.netmask.to_s
entry_mask.set_size_request(200, -1)
entry_mask.show
bbox=Gtk::HButtonBox.new
bbox.show
bbox.add entry_mask

table.attach(label_mask,0,1,3,4)
table.attach(bbox,1,2,3,4)

label_map = Gtk::Label.new "Network"
label_map.show
entry_map = Gtk::Entry.new
entry_map.set_editable false
entry_map.set_text(node.map)
entry_map.set_size_request(200, -1)
entry_map.show
bbox=Gtk::HButtonBox.new
bbox.show
bbox.add entry_map

table.attach(label_map,0,1,4,5)
table.attach(bbox,1,2,4,5)

label_mac = Gtk::Label.new "MAC"
label_mac.show
entry_mac = Gtk::Entry.new
entry_mac.set_text(node.mac)
entry_mac.set_size_request(200, -1)
entry_mac.show
bbox=Gtk::HButtonBox.new
bbox.show
bbox.add entry_mac
table.attach(label_mac,0,1,5,6)
table.attach(bbox,1,2,5,6)

label_name = Gtk::Label.new "DNS Name"
label_name.show
entry_name = Gtk::Entry.new
#local host can have name filled by facter and not the dns_name
if node.hostname?() and !node.dns_name?()
   entry_name.set_text(node.name)
else
   entry_name.set_text(node.dns_name)
end
entry_name.set_size_request(200, -1)
entry_name.show
bbox=Gtk::HButtonBox.new
bbox.show
bbox.add entry_name

table.attach(label_name,0,1,6,7)
table.attach(bbox,1,2,6,7)

label_netbiosname = Gtk::Label.new "Netbios Name"
label_netbiosname.show
entry_netbiosname = Gtk::Entry.new
entry_netbiosname.set_text(node.netbios_name)
entry_netbiosname.set_size_request(200, -1)
entry_netbiosname.show
bbox=Gtk::HButtonBox.new
bbox.show
bbox.add entry_netbiosname

table.attach(label_netbiosname,0,1,7,8)
table.attach(bbox,1,2,7,8)

label_os = Gtk::Label.new "OS"
label_os.show
entry_os =  Gtk::ImageComboList.new("os", "#{node.os}")
entry_os.set_size_request(200, -1)
entry_os.show
bbox=Gtk::HButtonBox.new
bbox.show
bbox.add entry_os

table.attach(label_os,0,1,8,9)
table.attach(bbox,1,2,8,9)

label_desc = Gtk::Label.new "Description"
label_desc.show
entry_desc = Gtk::Entry.new
entry_desc.set_text(node.description)
entry_desc.set_size_request(200, -1)
entry_desc.show
bbox=Gtk::HButtonBox.new
bbox.show
bbox.add entry_desc

table.attach(label_desc,0,1,9,10)
table.attach(bbox,1,2,9,10)

hbox = Gtk::HBox.new(FALSE, 1)
hbox.add Gtk::Image.new(Gtk::Stock::INFO, Gtk::IconSize::MENU)
hbox.add Gtk::Label::new("Information")
hbox.show_all

notebook_info.append_page frame_stored, Gtk::Label::new("Stored")

########## SNMP tab

frame_snmp_info = Gtk::Frame::new
frame_snmp_info.border_width=10
frame_snmp_info.set_size_request(300, 290)
frame_snmp_info.show

table = Gtk::Table.new(5,2,false)
table.show
frame_snmp_info.add table

label_desc = Gtk::Label.new "Description"
label_desc.show
entry_descsnmp = Gtk::Entry.new
entry_descsnmp.set_editable false

def snmp_description(entry, node, read_community)
	if $config.snmp_mon		
entry.set_text "(polling...)"
Thread.start {
 		val=get_snmp_description(node)
Gtk.thread_protect do
	begin
	   	entry.set_position 0
		entry.set_text val
	rescue Exception => msg
		$log.debug("Exception in snmp_description for #{node.ip}: #{msg}")
	end
end
 	}
else
Gtk.thread_protect do
		begin
		entry.set_sensitive(false)
	   	entry.set_text "(SNMP is disable)"
	rescue
		$log.debug("Exception in snmp_description for #{node.ip}: #{msg}")		
	end
end
end
end
 if node.get_account_id("snmp")
	  login, password = node.get_account_id("snmp") 
 snmp_description(entry_descsnmp, node, login)
	end
entry_descsnmp.set_size_request(200, -1)
entry_descsnmp.show
bbox=Gtk::HButtonBox.new
bbox.show
bbox.add entry_descsnmp

table.attach(label_desc,0,1,0,1)
table.attach(bbox,1,2,0,1)

label_uptime = Gtk::Label.new "Uptime"
label_uptime.show
entry_uptime = Gtk::Entry.new
entry_uptime.set_editable false
def snmp_uptime(entry, node, read_community)
if $config.snmp_mon
    entry.set_text "(polling...)"
 Thread.start {
 		val=get_snmp_uptime(node)
Gtk.thread_protect do
	begin
   		entry.set_position 0
		entry.set_text val
	rescue Exception => msg
		$log.debug("Exception in snmp_uptime for #{node.ip}: #{msg}")			
	end
end
 }
else
begin
	entry.set_sensitive(false)
  		entry.set_text "(SNMP is disable)"
rescue Exception => msg
	$log.debug("Exception in snmp_uptime for #{node.ip}: #{msg}")
end
end
end
if node.get_account_id("snmp")
	  login, password = node.get_account_id("snmp")
 snmp_uptime(entry_uptime, node, login)
end
	entry_uptime.set_size_request(200, -1)
entry_uptime.show
bbox=Gtk::HButtonBox.new
bbox.show
bbox.add entry_uptime

table.attach(label_uptime,0,1,1,2)
table.attach(bbox,1,2,1,2)

label_contact = Gtk::Label.new "Contact"
label_contact.show
entry_contact = Gtk::Entry.new
entry_contact.set_editable false
def snmp_contact(entry, node, read_community)
if $config.snmp_mon
   entry.set_text "(polling...)"
 Thread.start {
  	val=get_snmp_contact(node)
Gtk.thread_protect do
	begin
  			entry.set_position 0
		entry.set_text val
	rescue Exception => msg
		$log.debug("Exception in snmp_contact for #{node.ip}: #{msg}")
	end
end
 }
else
	Gtk.thread_protect do
	begin
		entry.set_sensitive(false)
   		entry.set_text "(SNMP is disable)"
	rescue Exception => msg
		$log.debug("Exception in snmp_contact for #{node.ip}: #{msg}")
	end
end

end
end
if node.get_account_id("snmp")
	  login, password = node.get_account_id("snmp")
 snmp_contact(entry_contact, node, login)
	end
entry_contact.set_size_request(200, -1)
entry_contact.show
bbox=Gtk::HButtonBox.new
bbox.show
bbox.add entry_contact

table.attach(label_contact,0,1,2,3)
table.attach(bbox,1,2,2,3)
label_location = Gtk::Label.new "Location"
label_location.show
entry_location = Gtk::Entry.new
entry_location.set_editable false
def snmp_location(entry, node, read_community)
if $config.snmp_mon
   entry.set_text "(polling...)"
 Thread.start {
  	val=get_snmp_location(node)
Gtk.thread_protect do
	begin
   		entry.set_position 0
		entry.set_text val
	rescue Exception => msg
		$log.debug("Exception in snmp_location for #{node.ip}: #{msg}")
	end
end
 }
else
Gtk.thread_protect do
		begin
		entry.set_sensitive(false)
	   	entry.set_text "(SNMP is disable)"
	rescue Exception => msg
		$log.debug("Exception in snmp_location for #{node.ip}: #{msg}")
	end
end
end
end
if node.get_account_id("snmp")
	  login, password = node.get_account_id("snmp")
snmp_location(entry_location, node, login)
	end
entry_location.set_size_request(200, -1)
entry_location.show
bbox=Gtk::HButtonBox.new
bbox.show
bbox.add entry_location

table.attach(label_location,0,1,3,4)
table.attach(bbox,1,2,3,4)

hbbox=Gtk::HButtonBox.new
refresh_button = Gtk::Button.new(Gtk::Stock::REFRESH)
if !$config.snmp_mon
	refresh_button.set_sensitive false
end
hbbox.add refresh_button
hbbox.show

refresh_button.signal_connect("clicked") do
	if node.get_account_id("snmp")
login, password = node.get_account_id("snmp")
 	snmp_description(entry_descsnmp, node, login)
snmp_uptime(entry_uptime, node, login)
snmp_contact(entry_contact, node, login)
snmp_location(entry_location, node, login)
	end
end

refresh_button.show
table.attach(hbbox,1,2,4,5)

notebook_info.append_page frame_snmp_info, Gtk::Label::new("SNMP")

########## WMI tab, info from Win32_ComputerSystem and Win32_OperatingSystem

frame_wmi_info = Gtk::Frame::new
frame_wmi_info.border_width=10
frame_wmi_info.set_size_request(300, 290)
frame_wmi_info.show

table = Gtk::Table.new(8,2,false)
table.show
frame_wmi_info.add table

label_desc = Gtk::Label.new "Description"
label_desc.show
entry_descwmi = Gtk::Entry.new
entry_descwmi.set_editable false

def wmi_description(entry, node, login ,pass)
	if $config.wmi_mon		
entry.set_text "(polling...)"
Thread.start {
 		val=get_wmi_description(login, pass, node.ip)
	if val
		Gtk.thread_protect do
			begin
			   	entry.set_position 0
				entry.set_text val
			rescue Exception => msg
				$log.debug("Exception in wmi_description for #{node.ip}: #{msg}")
			end
		end
	end
 	}
else
	begin
	entry.set_sensitive(false)
	entry.set_text "(WMI is disable)"
rescue
end
end
end
if node.get_account_id("wmi")
	  login, password = node.get_account_id("wmi")
 wmi_description(entry_descwmi, node, login, password)
end
entry_descwmi.set_size_request(200, -1)
entry_descwmi.show
bbox=Gtk::HButtonBox.new
bbox.show
bbox.add entry_descwmi

table.attach(label_desc,0,1,0,1)
table.attach(bbox,1,2,0,1)

label_boot = Gtk::Label.new "Bootup State"
label_boot.show
entry_bootwmi = Gtk::Entry.new
entry_bootwmi.set_editable false

def wmi_boot(entry, node, login ,pass)
	if $config.wmi_mon		
entry.set_text "(polling...)"
Thread.start {
 		val=get_wmi_boot_state(login, pass, node.ip)
	if val
		Gtk.thread_protect do
			begin
				entry.set_position 0
				entry.set_text val
			rescue Exception => msg
				$log.debug("Exception in wmi_boot for #{node.ip}: #{msg}")
			end
		end
	end
 	}
else
	Gtk.thread_protect do
 	begin
		entry.set_sensitive(false)
		entry.set_text "(WMI is disable)"
	rescue
	end
end
end
end

if node.get_account_id("wmi")
	  login, password = node.get_account_id("wmi")
 wmi_boot(entry_bootwmi, node, login, password)
end
entry_bootwmi.set_size_request(200, -1)
entry_bootwmi.show
bbox=Gtk::HButtonBox.new
bbox.show
bbox.add entry_bootwmi

table.attach(label_boot,0,1,1,2)
table.attach(bbox,1,2,1,2)

label_thermal = Gtk::Label.new "Thermal State"
label_thermal.show
entry_thermalwmi = Gtk::Entry.new
entry_thermalwmi.set_editable false

def wmi_thermal(entry, node, login ,pass)
	if $config.wmi_mon		
entry.set_text "(polling...)"
Thread.start {
 		val=get_wmi_thermal_state(login, pass, node.ip)
	if val
		Gtk.thread_protect do
			begin
		   		entry.set_position 0
				entry.set_text val
			rescue Exception => msg
				$log.debug("Exception in wmi_thermal for #{node.ip}: #{msg}")
			end
		end
	end
 	}
else
	begin
	entry.set_sensitive(false)
	entry.set_text "(WMI is disable)"
rescue
end
end
end

if node.get_account_id("wmi")
	  login, password = node.get_account_id("wmi")
 wmi_thermal(entry_thermalwmi, node, login, password)
end
entry_thermalwmi.set_size_request(200, -1)
entry_thermalwmi.show
bbox=Gtk::HButtonBox.new
bbox.show
bbox.add entry_thermalwmi

table.attach(label_thermal,0,1,2,3)
table.attach(bbox,1,2,2,3)

label_nbproc = Gtk::Label.new "Processor Number"
label_nbproc.show
entry_nbprocwmi = Gtk::Entry.new
entry_nbprocwmi.set_editable false

def wmi_nbproc(entry, node, login ,pass)
	if $config.wmi_mon		
entry.set_text "(polling...)"
Thread.start {
 		val=get_wmi_nb_proc(login, pass, node.ip)
	if val
		Gtk.thread_protect do
			begin
			   	entry.set_position 0
				entry.set_text val
			rescue Exception => msg
				$log.debug("Exception in wmi_nbproc for #{node.ip}: #{msg}")
			end
		end
	end
 	}
else
	begin
	entry.set_sensitive(false)
	entry.set_text "(WMI is disable)"
rescue
end
end
end

if node.get_account_id("wmi")
	  login, password = node.get_account_id("wmi")
 wmi_nbproc(entry_nbprocwmi, node, login, password)
end
entry_nbprocwmi.set_size_request(200, -1)
entry_nbprocwmi.show
bbox=Gtk::HButtonBox.new
bbox.show
bbox.add entry_nbprocwmi

table.attach(label_nbproc,0,1,3,4)
table.attach(bbox,1,2,3,4)

label_systype = Gtk::Label.new "System Type"
label_systype.show
entry_systype = Gtk::Entry.new
entry_systype.set_editable false

def wmi_systype(entry, node, login ,pass)
	if $config.wmi_mon		
entry.set_text "(polling...)"
Thread.start {
 		val=get_wmi_system_type(login, pass, node.ip)
	if val
		Gtk.thread_protect do
			begin
			   	entry.set_position 0
				entry.set_text val
			rescue Exception => msg
				$log.debug("Exception in wmi_systype for #{node.ip}: #{msg}")
			end
		end
	end
 	}
else
	begin
	entry.set_sensitive(false)
	entry.set_text "(WMI is disable)"
rescue
end
end
end

if node.get_account_id("wmi")
	  login, password = node.get_account_id("wmi")
 wmi_systype(entry_systype, node, login, password)
end
entry_systype.set_size_request(200, -1)
entry_systype.show
bbox=Gtk::HButtonBox.new
bbox.show
bbox.add entry_systype

table.attach(label_systype,0,1,4,5)
table.attach(bbox,1,2,4,5)

label_oswmi = Gtk::Label.new "OS"
label_oswmi.show
entry_oswmi = Gtk::Entry.new
entry_oswmi.set_editable false

def wmi_os(entry, node, login ,pass)
	if $config.wmi_mon		
entry.set_text "(polling...)"
Thread.start {
 		val=get_wmi_os(login, pass, node.ip)
if val
	Gtk.thread_protect do
		begin
		   	entry.set_position 0
			entry.set_text val
		rescue Exception => msg
			$log.debug("Exception in wmi_os for #{node.ip}: #{msg}")
		end
	end
end
 	}
else
	begin
	entry.set_sensitive(false)
	entry.set_text "(WMI is disable)"
rescue
end
end
end

if node.get_account_id("wmi")
	  login, password = node.get_account_id("wmi")
 wmi_os(entry_oswmi, node, login, password)
end
entry_oswmi.set_size_request(200, -1)
entry_oswmi.show
bbox=Gtk::HButtonBox.new
bbox.show
bbox.add entry_oswmi

table.attach(label_oswmi,0,1,5,6)
table.attach(bbox,1,2,5,6)

label_producttype = Gtk::Label.new "Product Type"
label_producttype.show
entry_producttype = Gtk::Entry.new
entry_producttype.set_editable false

def wmi_producttype(entry, node, login ,pass)
	if $config.wmi_mon		
entry.set_text "(polling...)"
Thread.start {
 		val=get_wmi_product_type(login, pass, node.ip)
if val
	Gtk.thread_protect do
		begin
		   	entry.set_position 0
			entry.set_text val
		rescue Exception => msg
			$log.debug("Exception in wmi_producttype for #{node.ip}: #{msg}")
		end
	end
end
 	}
else
	begin
	entry.set_sensitive(false)
	entry.set_text "(WMI is disable)"
rescue
end
end
end

if node.get_account_id("wmi")
	  login, password = node.get_account_id("wmi")
 wmi_producttype(entry_producttype, node, login, password)
end
entry_producttype.set_size_request(200, -1)
entry_producttype.show
bbox=Gtk::HButtonBox.new
bbox.show
bbox.add entry_producttype

table.attach(label_producttype,0,1,6,7)
table.attach(bbox,1,2,6,7)

hbbox=Gtk::HButtonBox.new
refresh_button_wmi = Gtk::Button.new(Gtk::Stock::REFRESH)
if !$config.wmi_mon
	refresh_button_wmi.set_sensitive false
end
hbbox.add refresh_button_wmi
hbbox.show

refresh_button_wmi.signal_connect("clicked") do
	if node.get_account_id("wmi")
login, password = node.get_account_id("wmi")
wmi_description(entry_descwmi, node, login, password)
 	wmi_boot(entry_bootwmi, node, login, password)
 	wmi_thermal(entry_thermalwmi, node, login, password)
 	wmi_nbproc(entry_nbprocwmi, node, login, password)
wmi_systype(entry_systype, node, login, password)		
wmi_os(entry_oswmi, node, login, password)
wmi_producttype(entry_producttype, node, login, password)
	end
end

refresh_button_wmi.show
table.attach(hbbox,1,2,7,8)


notebook_info.append_page frame_wmi_info, Gtk::Label::new("WMI")

notebook.append_page notebook_info, hbox

###############################Account conf########################

eval IO.read("#{GNMSLIB}"+'/gui/sub/account_frame.rb')

########### begin port monitoring #################################

frame = Gtk::Frame::new
frame.border_width=10
frame.show

vvbox = Gtk::VBox::new
vvbox.show
vvbox.add frame

vbox = Gtk::VBox::new(false,3)
vbox.show
frame.add vbox  

@vbox_ports = Gtk::VBox::new
@vbox_ports.show

#scrolled_window.add_with_viewport(vbox_ports)
#vbox_ports.set_focus_vadjustment(scrolled_window.vadjustment)
#scrolled_window.show
vbox.add @vbox_ports
@scan_port_th=nil
@cbutton=[]
@scanned_port_list=nil

######################## nmap thread ##################################

 ls = Gtk::ListStore.new(Integer, String, Integer, String, String)
 @treeview = Gtk::TreeView.new(ls)

 renderer = Gtk::CellRendererToggle.new
 renderer.signal_connect('toggled') do |cell, path|
 # get toggled iter
 iter = @treeview.model.get_iter(path)
 fixed =iter[0]
 # do something with the value
 fixed ^= 1
 @cbutton[path.to_i()]=fixed
 # set new value
 iter[0] = fixed
 end

	column1 = Gtk::TreeViewColumn.new("Enabled",
			 renderer, {:active => 0})
	column1.set_clickable(true)
	column2 = Gtk::TreeViewColumn.new("Protocol",
			 Gtk::CellRendererText.new, {:text => 1})
	column2.set_sort_column_id(1)
	column3 = Gtk::TreeViewColumn.new("Port",
			 Gtk::CellRendererText.new, {:text => 2})
	column3.set_sort_column_id(2)
	column4 = Gtk::TreeViewColumn.new("Service",
			 Gtk::CellRendererText.new, {:text => 3})
	column4.set_sort_column_id(3)
	sev_renderer = Gtk::CellRendererText.new
      column5 = Gtk::TreeViewColumn.new("Severity", sev_renderer, {:text => 4})
      column5.set_sort_column_id(4)
	
	column5.set_cell_data_func(sev_renderer) do |col, renderer, model, iter|
 if iter[4] and iter[4] != ""
   renderer.set_background_gdk(@color_style[$status.index(iter[4])])
 else
   renderer.background = nil
 end
      end
	
	column1.signal_connect("clicked") do |column|
toggle_select_port()
	end  

	@treeview.append_column(column1)
	@treeview.append_column(column2)
	@treeview.append_column(column3)
	@treeview.append_column(column4)
	@treeview.append_column(column5)
	@treeview.show

	# Create a menu
	menu_port = Gtk::Menu.new

	item_add_serv = Gtk::ImageMenuItem.new("Add service")
image_item_add_serv = Gtk::Image.new() 
image_item_add_serv.set_stock(Gtk::Stock::ADD) 
	item_add_serv.set_image(image_item_add_serv)
	item_add_serv.signal_connect("activate") { add_monitored_service() }
	menu_port.append(item_add_serv)

	item_del_serv = Gtk::ImageMenuItem.new("Delete selected service")
image_item_del_serv = Gtk::Image.new() 
image_item_del_serv.set_stock(Gtk::Stock::REMOVE) 
	item_del_serv.set_image(image_item_del_serv)
	item_del_serv.signal_connect("activate") {
@treeview.model.remove(@treeview.selection.selected) unless @treeview.selection.selected==nil
	}
	menu_port.append(item_del_serv)

	item_edit_serv = Gtk::ImageMenuItem.new("Edit service")
image_item_edit_serv = Gtk::Image.new() 
image_item_edit_serv.set_stock(Gtk::Stock::EDIT) 
	item_edit_serv.set_image(image_item_edit_serv)
	item_edit_serv.signal_connect("activate") { edit_monitored_service() }
	menu_port.append(item_edit_serv)

	scan_port_serv = Gtk::ImageMenuItem.new("Test service")
image_scan_port_serv = Gtk::Image.new() 
image_scan_port_serv.set_stock(Gtk::Stock::DIALOG_QUESTION) 
	scan_port_serv.set_image(image_scan_port_serv)
	scan_port_serv.signal_connect("activate") { scan_port_now(node) }
	menu_port.append(scan_port_serv)

	scan_ports_serv = Gtk::ImageMenuItem.new("Scan all ports")
image_scan_ports_serv = Gtk::Image.new() 
image_scan_ports_serv.set_stock(Gtk::Stock::REFRESH) 
	scan_ports_serv.set_image(image_scan_ports_serv)
	scan_ports_serv.signal_connect("activate") { scan_ports_now(node) }
	menu_port.append(scan_ports_serv)

	item_sw_serv = Gtk::MenuItem.new("Switch selection")
	item_sw_serv.signal_connect("activate") { toggle_select_port() }
	menu_port.append(item_sw_serv)
	menu_port.show_all

      @treeview.signal_connect("key_press_event") do |tview,e|
  if e.keyval == Gdk::Keyval::GDK_Delete
     tview.model.remove(tview.selection.selected) unless tview.selection.selected==nil
  end
	end

	@treeview.signal_connect("button_press_event") do |widget, event|
 if event.kind_of? Gdk::EventButton and event.button == 3
 if @treeview.selection.selected==nil 
	 item_edit_serv.set_sensitive(false)
	 item_del_serv.set_sensitive(false)
	 scan_port_serv.set_sensitive(false)
 else
	 item_edit_serv.set_sensitive(true)
	 item_del_serv.set_sensitive(true)
	 scan_port_serv.set_sensitive(true)
 end
 if $config.nmap_vers.to_f() == 0.0
   scan_ports_serv.set_sensitive(false)
 else
   scan_ports_serv.set_sensitive(true)
 end
 	 menu_port.popup(nil, nil, event.button, event.time)
 elsif (@treeview.selection.selected!=nil) && (event.event_type == Gdk::Event::BUTTON2_PRESS)
edit_monitored_service()	
 end
	end

fill_port_list(node)
fill_port_view(node)

if !$config.port_mon
@treeview.set_sensitive false
@treeview.show
frame.set_label("This monitoring is disabled")
end

notebook_inside = Gtk::Notebook::new()
label_port = Gtk::Label::new("Service")
notebook_inside.append_page(vvbox, label_port)
notebook_inside.show

######################### snmp oid monitoring ###################################################################

frame = Gtk::Frame::new
frame.border_width=10
frame.set_size_request(300, 290)
frame.show

vbox = Gtk::VBox::new
vbox.show
frame.add vbox

snmp_ls = Gtk::ListStore.new(Integer, String, String, String, String)
@snmpview = Gtk::TreeView.new(snmp_ls)

 renderer_snmp = Gtk::CellRendererToggle.new
 renderer_snmp.signal_connect('toggled') do |cell, path|
 # get toggled iter
 iter = @snmpview.model.get_iter(path)
 fixed =iter[0]
 # do something with the value
 fixed ^= 1
 # set new value
 iter[0] = fixed
 end

if !$config.snmp_mon
@snmpview.set_sensitive false
frame.set_label("This monitoring is disabled")
end

if OIDRef::oid_ref_nb_entry() == 0
	 @snmpview.set_sensitive false
frame.set_label("No SNMP OID defined, go in Tools menu")
end

column1 = Gtk::TreeViewColumn.new("Enabled",
			renderer_snmp, {:active => 0})
column1.set_clickable(true)
column2 = Gtk::TreeViewColumn.new("OID label",
			Gtk::CellRendererText.new, {:text => 1})
column2.set_sort_column_id(1)
column3 = Gtk::TreeViewColumn.new("Operator",
			Gtk::CellRendererText.new, {:text => 2})
column3.set_sort_column_id(2)
tr=Gtk::CellRendererText.new
tr.mode=Gtk::CellRenderer::MODE_EDITABLE
column4 = Gtk::TreeViewColumn.new("Threshold",
			tr, {:text => 3})
column4.set_sort_column_id(3)
sev_renderer = Gtk::CellRendererText.new
column5 = Gtk::TreeViewColumn.new("Severity",	sev_renderer, {:text => 4})
column5.set_sort_column_id(4)

column5.set_cell_data_func(sev_renderer) do |col, renderer, model, iter|
  if iter[4] and iter[4] != ""
    renderer.set_background_gdk(@color_style[$status.index(iter[4])])
  else
    renderer.background = nil
  end
end

@snmpview.append_column(column1)
@snmpview.append_column(column2)
@snmpview.append_column(column3)
@snmpview.append_column(column4)
@snmpview.append_column(column5)
@snmpview.show

	# Create a menu
	menu_snmp = Gtk::Menu.new

	item_add_snmp = Gtk::ImageMenuItem.new("Add SNMP Ref")
image_item_add_snmp = Gtk::Image.new() 
image_item_add_snmp.set_stock(Gtk::Stock::ADD) 
	item_add_snmp.set_image(image_item_add_snmp)
	item_add_snmp.signal_connect("activate") { add_monitored_snmp() unless OIDRef::get_oid_refs_name().size() == 0 }
	menu_snmp.append(item_add_snmp)

	item_del_snmp = Gtk::ImageMenuItem.new("Delete selected SNMP Ref")
image_item_del_snmp = Gtk::Image.new() 
image_item_del_snmp.set_stock(Gtk::Stock::REMOVE) 
	item_del_snmp.set_image(image_item_del_snmp)
	item_del_snmp.signal_connect("activate") {
@snmpview.model.remove(@snmpview.selection.selected) unless @snmpview.selection.selected==nil
	}
	menu_snmp.append(item_del_snmp)

	item_edit_snmp = Gtk::ImageMenuItem.new("Edit SNMP Ref")
image_edit_snmp = Gtk::Image.new() 
image_edit_snmp.set_stock(Gtk::Stock::EDIT) 
	item_edit_snmp.set_image(image_edit_snmp)
	item_edit_snmp.signal_connect("activate") { edit_monitored_snmp() }
	menu_snmp.append(item_edit_snmp)

	menu_snmp.show_all

	@snmpview.signal_connect("button_press_event") do |widget, event|
 if event.kind_of? Gdk::EventButton and event.button == 3
if @snmpview.selection.selected==nil 
	item_edit_snmp.set_sensitive(false)
	item_del_snmp.set_sensitive(false)
else
	item_edit_snmp.set_sensitive(true)
	item_del_snmp.set_sensitive(true)
end
if OIDRef::get_oid_refs_name().size() > 0
	item_add_snmp.set_sensitive(true)
else
	item_add_snmp.set_sensitive(false)
end
 	menu_snmp.popup(nil, nil, event.button, event.time)
 elsif (@snmpview.selection.selected!=nil) && (event.event_type == Gdk::Event::BUTTON2_PRESS)
edit_monitored_snmp()	
 end
	end

	#populate with saved values
 node.snmp_monitoring.each_value do |snmp_mon|
 iter = snmp_ls.append
 iter[0] = snmp_mon.get_state()
 iter[1] = snmp_mon.oidref
 iter[2] = snmp_mon.oper
 iter[3] = snmp_mon.threshold.to_s
 iter[4] = snmp_mon.severity
	end

	vbox.add(@snmpview)

label_snmp = Gtk::Label::new("SNMP")
notebook_inside.append_page frame, label_snmp

######################### end snmp oid monitoring ##########################################################

######################### wmi monitoring ###################################################################

frame = Gtk::Frame::new
frame.border_width=10
frame.set_size_request(300, 290)
frame.show

vbox = Gtk::VBox::new
vbox.show
frame.add vbox

wmi_ls = Gtk::ListStore.new(Integer, String, String, String, String)
@wmiview = Gtk::TreeView.new(wmi_ls)

 renderer_wmi = Gtk::CellRendererToggle.new
 renderer_wmi.signal_connect('toggled') do |cell, path|
 # get toggled iter
 iter = @wmiview.model.get_iter(path)
 fixed =iter[0]
 # do something with the value
 fixed ^= 1
 # set new value
 iter[0] = fixed
 end

if !$config.wmi_mon
@wmiview.set_sensitive false
frame.set_label("This monitoring is disabled")
end

if WMIRef::wmi_ref_nb_entry() == 0
	 @wmiview.set_sensitive false
frame.set_label("No WMI request defined, go in Tools menu")
end

column1 = Gtk::TreeViewColumn.new("Enabled",
			renderer_wmi, {:active => 0})
column1.set_clickable(true)
column2 = Gtk::TreeViewColumn.new("WMI label",
			Gtk::CellRendererText.new, {:text => 1})
column2.set_sort_column_id(1)
column3 = Gtk::TreeViewColumn.new("Operator",
			Gtk::CellRendererText.new, {:text => 2})
column3.set_sort_column_id(2)
tr=Gtk::CellRendererText.new
tr.mode=Gtk::CellRenderer::MODE_EDITABLE
column4 = Gtk::TreeViewColumn.new("Threshold",
			tr, {:text => 3})
column4.set_sort_column_id(3)
sev_renderer = Gtk::CellRendererText.new
column5 = Gtk::TreeViewColumn.new("Severity", sev_renderer, {:text => 4})
column5.set_sort_column_id(4)

column5.set_cell_data_func(sev_renderer) do |col, renderer, model, iter|
  if iter[4] and iter[4] != ""
    renderer.set_background_gdk(@color_style[$status.index(iter[4])])
  else
    renderer.background = nil
  end
end

@wmiview.append_column(column1)
@wmiview.append_column(column2)
@wmiview.append_column(column3)
@wmiview.append_column(column4)
@wmiview.append_column(column5)
@wmiview.show

	# Create a popup menu
	menu_wmi = Gtk::Menu.new

	item_add_wmi = Gtk::ImageMenuItem.new("Add WMI Ref")
image_item_add_wmi = Gtk::Image.new()
image_item_add_wmi.set_stock(Gtk::Stock::ADD)
	item_add_wmi.set_image(image_item_add_wmi)
	item_add_wmi.signal_connect("activate") { add_monitored_wmi() unless WMIRef::get_wmi_refs_name().size() == 0 }
	menu_wmi.append(item_add_wmi)

	item_del_wmi = Gtk::ImageMenuItem.new("Delete selected WMI Ref")
image_item_del_wmi = Gtk::Image.new() 
image_item_del_wmi.set_stock(Gtk::Stock::REMOVE) 
	item_del_wmi.set_image(image_item_del_wmi)
	item_del_wmi.signal_connect("activate") {
@wmiview.model.remove(@wmiview.selection.selected) unless @wmiview.selection.selected==nil
	}
	menu_wmi.append(item_del_wmi)

	item_edit_wmi = Gtk::ImageMenuItem.new("Edit WMI Ref")
image_edit_wmi = Gtk::Image.new() 
image_edit_wmi.set_stock(Gtk::Stock::EDIT) 
	item_edit_wmi.set_image(image_edit_wmi)
	item_edit_wmi.signal_connect("activate") { edit_monitored_wmi() }
	menu_wmi.append(item_edit_wmi)

	menu_wmi.show_all

	@wmiview.signal_connect("button_press_event") do |widget, event|
 if event.kind_of? Gdk::EventButton and event.button == 3
if @wmiview.selection.selected==nil 
	item_edit_wmi.set_sensitive(false)
	item_del_wmi.set_sensitive(false)
else
	item_edit_wmi.set_sensitive(true)
	item_del_wmi.set_sensitive(true)
end
if WMIRef::get_wmi_refs_name().size() > 0
	item_add_wmi.set_sensitive(true)
else
	item_add_wmi.set_sensitive(false)
end
 	menu_wmi.popup(nil, nil, event.button, event.time)
 elsif (@wmiview.selection.selected!=nil) && (event.event_type == Gdk::Event::BUTTON2_PRESS)
edit_monitored_wmi()	
 end
	end

	#populate with saved values
 node.wmi_monitoring.each_value do |wmi_mon|
 iter = wmi_ls.append
 iter[0] = wmi_mon.get_state()
 iter[1] = wmi_mon.wmiref
 iter[2] = wmi_mon.oper
 iter[3] = wmi_mon.value.to_s
 iter[4] = wmi_mon.severity
	end

	vbox.add(@wmiview)

label_wmi = Gtk::Label::new("WMI")
notebook_inside.append_page frame, label_wmi

###########################end wmi monitoring#####################################################################

######################### jmx monitoring ###################################################################

frame = Gtk::Frame::new
frame.border_width=10
frame.set_size_request(300, 290)
frame.show

vbox = Gtk::VBox::new
vbox.show
frame.add vbox

jmx_ls = Gtk::ListStore.new(Integer, String, String, String)
@jmxview = Gtk::TreeView.new(jmx_ls)

 renderer_jmx = Gtk::CellRendererToggle.new
 renderer_jmx.signal_connect('toggled') do |cell, path|
 # get toggled iter
 iter = @jmxview.model.get_iter(path)
 fixed =iter[0]
 # do something with the value
 fixed ^= 1
 # set new value
 iter[0] = fixed
 node.jmx_monitoring[iter[1]].set_state(fixed.to_i)
 end

if !$config.jmx_mon
@jmxview.set_sensitive false
frame.set_label("This monitoring is disabled")
end

if JMXRef::jmx_ref_nb_entry() == 0
	 @jmxview.set_sensitive false
frame.set_label("No jmx request defined, go in Tools menu")
end

column1 = Gtk::TreeViewColumn.new("Enabled",
			renderer_jmx, {:active => 0})
column1.set_clickable(true)
column2 = Gtk::TreeViewColumn.new("Label",
			Gtk::CellRendererText.new, {:text => 1})
column2.set_sort_column_id(1)
column3 = Gtk::TreeViewColumn.new("Protocol/Port",
			Gtk::CellRendererText.new, {:text => 2})
column3.set_sort_column_id(2)
column4 = Gtk::TreeViewColumn.new("Auth",
			Gtk::CellRendererText.new, {:text => 3})
column4.set_sort_column_id(3)

@jmxview.append_column(column1)
@jmxview.append_column(column2)
@jmxview.append_column(column3)
@jmxview.append_column(column4)
@jmxview.show

	# Create a popup menu
	menu_jmx = Gtk::Menu.new

	item_add_jmx = Gtk::ImageMenuItem.new("Add JMX Ref")
image_item_add_jmx = Gtk::Image.new()
image_item_add_jmx.set_stock(Gtk::Stock::ADD)
	item_add_jmx.set_image(image_item_add_jmx)
	item_add_jmx.signal_connect("activate") { add_monitored_jmx(node) unless JMXRef::get_jmx_refs_name().size() == 0 }
	menu_jmx.append(item_add_jmx)

	item_del_jmx = Gtk::ImageMenuItem.new("Delete selected JMX Ref")
image_item_del_jmx = Gtk::Image.new() 
image_item_del_jmx.set_stock(Gtk::Stock::REMOVE) 
	item_del_jmx.set_image(image_item_del_jmx)
	item_del_jmx.signal_connect("activate") {
@jmxview.model.remove(@jmxview.selection.selected) unless @jmxview.selection.selected==nil
	}
	menu_jmx.append(item_del_jmx)

	item_edit_jmx = Gtk::ImageMenuItem.new("Edit JMX Ref")
image_edit_jmx = Gtk::Image.new() 
image_edit_jmx.set_stock(Gtk::Stock::EDIT) 
	item_edit_jmx.set_image(image_edit_jmx)
	item_edit_jmx.signal_connect("activate") { edit_monitored_jmx(node) }
	menu_jmx.append(item_edit_jmx)

	menu_jmx.show_all

	@jmxview.signal_connect("button_press_event") do |widget, event|
 if event.kind_of? Gdk::EventButton and event.button == 3
if @jmxview.selection.selected==nil 
	item_edit_jmx.set_sensitive(false)
	item_del_jmx.set_sensitive(false)
else
	item_edit_jmx.set_sensitive(true)
	item_del_jmx.set_sensitive(true)
end
if JMXRef::get_jmx_refs_name().size() > 0
	item_add_jmx.set_sensitive(true)
else
	item_add_jmx.set_sensitive(false)
end
 	menu_jmx.popup(nil, nil, event.button, event.time)
 elsif (@jmxview.selection.selected!=nil) && (event.event_type == Gdk::Event::BUTTON2_PRESS)
edit_monitored_jmx(node)	
 end
	end

	#populate with saved values
 node.jmx_monitoring.each_value do |jmx_mon|
 iter = jmx_ls.append
 iter[0] = jmx_mon.get_state()
 iter[1] = jmx_mon.get_ref()
 iter[2] = "#{jmx_mon.get_protocol()}/#{jmx_mon.get_port()}"
 iter[3] = jmx_mon.get_auth()
	end

	vbox.add(@jmxview)

label_jmx = Gtk::Label::new("JMX")
notebook_inside.append_page frame, label_jmx

###########################end jmx monitoring#####################################################################

######################### snmp trap monitoring ###################################################################

frame = Gtk::Frame::new
frame.border_width=10
frame.set_size_request(300, 290)
frame.show

vbox = Gtk::VBox::new
vbox.show
frame.add vbox

snmp_trap_ls = Gtk::ListStore.new(Integer, String, String, String)
@snmptrapview = Gtk::TreeView.new(snmp_trap_ls)
@snmptrapview.set_tooltip_column(3)  

 renderer_snmp = Gtk::CellRendererToggle.new
 renderer_snmp.signal_connect('toggled') do |cell, path|
 # get toggled iter
 iter = @snmptrapview.model.get_iter(path)
 fixed =iter[0]
 # do something with the value
 fixed ^= 1
 # set new value
 iter[0] = fixed
 end

if !$config.snmptrap_mon
 @snmptrapview.set_sensitive false
frame.set_label("This monitoring is disabled")
end

column1 = Gtk::TreeViewColumn.new("Enabled",
			renderer_snmp, {:active => 0})
column1.set_clickable(true)
column2 = Gtk::TreeViewColumn.new("Trap label",
			Gtk::CellRendererText.new, {:text => 1})
column2.set_sort_column_id(1)
sev_renderer = Gtk::CellRendererText.new
column3 = Gtk::TreeViewColumn.new("Severity",	sev_renderer, {:text => 2})
column4 = Gtk::TreeViewColumn.new("Description",
			Gtk::CellRendererText.new, {:text => 3})          
column4.visible = false
column3.set_cell_data_func(sev_renderer) do |col, renderer, model, iter|
  if iter[2] and iter[2] != ""
    renderer.set_background_gdk(@color_style[$status.index(iter[2])])
  else
    renderer.background = nil
  end
end

@snmptrapview.append_column(column1)
@snmptrapview.append_column(column2)
@snmptrapview.append_column(column3)
@snmptrapview.append_column(column4)
@snmptrapview.show

	# Create a menu
	menu_snmptrap = Gtk::Menu.new
	item_add_snmptrap = Gtk::ImageMenuItem.new("Add SNMP Trap")
image_item_add_snmptrap = Gtk::Image.new() 
image_item_add_snmptrap.set_stock(Gtk::Stock::ADD) 
	item_add_snmptrap.set_image(image_item_add_snmptrap)
	item_add_snmptrap.signal_connect("activate") { add_monitored_snmptrap() unless SnmpTrapRef::get_snmptrap_refs_name().size() == 0 }
	menu_snmptrap.append(item_add_snmptrap)

	item_del_snmptrap = Gtk::ImageMenuItem.new("Delete selected SNMP Trap")
image_item_del_snmptrap = Gtk::Image.new() 
image_item_del_snmp.set_stock(Gtk::Stock::REMOVE) 
	item_del_snmptrap.set_image(image_item_del_snmptrap)
	item_del_snmptrap.signal_connect("activate") {
@snmptrapview.model.remove(@snmptrapview.selection.selected) unless @snmptrapview.selection.selected==nil
	}
	menu_snmptrap.append(item_del_snmptrap)

	item_edit_snmptrap = Gtk::ImageMenuItem.new("Edit SNMP Trap")
image_edit_snmptrap = Gtk::Image.new() 
image_edit_snmptrap.set_stock(Gtk::Stock::EDIT) 
	item_edit_snmptrap.set_image(image_edit_snmptrap)
	item_edit_snmptrap.signal_connect("activate") { edit_monitored_snmp() }
	menu_snmptrap.append(item_edit_snmptrap)

	menu_snmptrap.show_all

	@snmptrapview.signal_connect("button_press_event") do |widget, event|
 if event.kind_of? Gdk::EventButton and event.button == 3
if @snmptrapview.selection.selected==nil 
	item_edit_snmptrap.set_sensitive(false)
	item_del_snmptrap.set_sensitive(false)
else
	item_edit_snmptrap.set_sensitive(true)
	item_del_snmptrap.set_sensitive(true)
end
if SnmpTrapRef::get_snmptrap_refs_name().size() > 0 && get_snmptrap_refs_left().size() > 0
	item_add_snmptrap.set_sensitive(true)
else
	item_add_snmptrap.set_sensitive(false)
end
 	menu_snmptrap.popup(nil, nil, event.button, event.time)
 elsif (@snmptrapview.selection.selected!=nil) && (event.event_type == Gdk::Event::BUTTON2_PRESS)
edit_monitored_snmptrap()	
 end
	end

	#populate with saved values
 node.snmptrap_monitoring.each_value do |snmptrap_mon|
 iter = snmp_trap_ls.append
 iter[0] = snmptrap_mon.get_state()
 iter[1] = snmptrap_mon.get_snmptrap_ref()
 iter[2] = snmptrap_mon.severity()
        iter[3] = $snmptrap_refs[snmptrap_mon.get_snmptrap_ref()].description
	end

	vbox.add(@snmptrapview)

label_snmptrap = Gtk::Label::new("SNMP trap")
notebook_inside.append_page frame, label_snmptrap

###########################end snmp trap monitoring############################################################

######################### syslog monitoring ###################################################################

frame = Gtk::Frame::new
frame.border_width=10
frame.set_size_request(300, 290)
frame.show

vbox = Gtk::VBox::new
vbox.show
frame.add vbox

syslog_ls = Gtk::ListStore.new(Integer, String, String, String)
@syslogview = Gtk::TreeView.new(syslog_ls)
@syslogview.set_tooltip_column(3)  

 renderer_syslog = Gtk::CellRendererToggle.new
 renderer_syslog.signal_connect('toggled') do |cell, path|
 # get toggled iter
 iter = @syslogview.model.get_iter(path)
 fixed =iter[0]
 # do something with the value
 fixed ^= 1
 # set new value
 iter[0] = fixed
 end

if !$config.syslog_mon
 @syslogview.set_sensitive false
frame.set_label("This monitoring is disabled")
end

column1 = Gtk::TreeViewColumn.new("Enabled",
			renderer_syslog, {:active => 0})
column1.set_clickable(true)
column2 = Gtk::TreeViewColumn.new("Syslog label",
			Gtk::CellRendererText.new, {:text => 1})
column2.set_sort_column_id(1)
sev_renderer = Gtk::CellRendererText.new  
column3 = Gtk::TreeViewColumn.new("Severity",	sev_renderer, {:text => 2})
column4 = Gtk::TreeViewColumn.new("Description", Gtk::CellRendererText.new, {:text => 3})
column4.visible = false
column3.set_cell_data_func(sev_renderer) do |col, renderer, model, iter|
  if iter[2] and iter[2] != ""
    ind = $status.index(iter[2])
    if ind
      color = @color_style[ind]
      if color
        renderer.set_background_gdk(color)
      end
      next
    end
  end
  renderer.background = nil
end

@syslogview.append_column(column1)
@syslogview.append_column(column2)
@syslogview.append_column(column3)
@syslogview.append_column(column4)
@syslogview.show

	# Create a menu
	menu_syslog = Gtk::Menu.new

	item_add_syslog = Gtk::ImageMenuItem.new("Add Syslog Ref")
image_item_add_syslog = Gtk::Image.new() 
image_item_add_syslog.set_stock(Gtk::Stock::ADD) 
	item_add_syslog.set_image(image_item_add_syslog)
	item_add_syslog.signal_connect("activate") {	
add_monitored_syslog() unless SyslogRef::get_syslog_refs_name().size() == 0
}
	
	menu_syslog.append(item_add_syslog)

	item_del_syslog = Gtk::ImageMenuItem.new("Delete selected Syslog Ref")
image_item_del_syslog = Gtk::Image.new() 
image_item_del_syslog.set_stock(Gtk::Stock::REMOVE) 
	item_del_syslog.set_image(image_item_del_syslog)
	item_del_syslog.signal_connect("activate") {
@syslogview.model.remove(@syslogview.selection.selected) unless @syslogview.selection.selected==nil
	}
	menu_syslog.append(item_del_syslog)

	item_edit_syslog = Gtk::ImageMenuItem.new("Edit Syslog Ref")
	image_item_edit_syslog = Gtk::Image.new() 
	image_item_edit_syslog.set_stock(Gtk::Stock::EDIT) 
	item_edit_syslog.set_image(image_item_edit_syslog)
	item_edit_syslog.signal_connect("activate") { edit_monitored_syslog() }
	menu_syslog.append(item_edit_syslog)

	menu_syslog.show_all

	@syslogview.signal_connect("button_press_event") do |widget, event|
 if event.kind_of? Gdk::EventButton and event.button == 3
 if @syslogview.selection.selected==nil 
	 item_edit_syslog.set_sensitive(false)
	 item_del_syslog.set_sensitive(false)
 else
	 item_edit_syslog.set_sensitive(true)
	 item_del_syslog.set_sensitive(true)
 end
if SyslogRef::get_syslog_refs_name().size() > 0 && get_syslog_refs_left().size() > 0
	item_add_syslog.set_sensitive(true)
else
	item_add_syslog.set_sensitive(false)
end
 	 menu_syslog.popup(nil, nil, event.button, event.time)
 elsif (@syslogview.selection.selected!=nil) && (event.event_type == Gdk::Event::BUTTON2_PRESS)
edit_monitored_syslog()	
 end
	end

	#populate with saved values
 node.syslog_monitoring.each_value do |syslog_mon|
 iter = syslog_ls.append
 iter[0] = syslog_mon.get_state()
 iter[1] = syslog_mon.get_syslog_ref()
	if syslog_mon.raw_severity()>0
 iter[2] = syslog_mon.severity()
	else
 iter[2] = MAP_SYSLOG_SEV
	end
 iter[3] = $syslog_refs[syslog_mon.get_syslog_ref()].description
	end

	vbox.add(@syslogview)

label_syslog = Gtk::Label::new("Syslog")
notebook_inside.append_page frame, label_syslog

###########################end syslog monitoring#################################################################

######################### external cmd/plugin monitoring ###################################################################

frame = Gtk::Frame::new
frame.border_width=10
frame.set_size_request(300, 290)
frame.show

vbox = Gtk::VBox::new
vbox.show
frame.add vbox 

custom_ls = Gtk::ListStore.new(Integer, String, String, String, String)
@customview = Gtk::TreeView.new(custom_ls)
@customview.set_tooltip_column(4)

if !$config.custom_mon
@customview.set_sensitive false
frame.set_label("This monitoring is disabled")
end

renderer = Gtk::CellRendererToggle.new
renderer.signal_connect('toggled') do |cell, path|
# get toggled iter
iter = @customview.model.get_iter(path)
fixed =iter[0]
# do something with the value
fixed ^= 1
# set new value
iter[0] = fixed
end

column1 = Gtk::TreeViewColumn.new("Enabled",
			renderer, {:active => 0})
column1.set_clickable(true)
column2 = Gtk::TreeViewColumn.new("Name",
			Gtk::CellRendererText.new, {:text => 1})      
  
column2.set_sort_column_id(1)
renderer = Gtk::CellRendererText.new
renderer.set_editable(true)

sev_ls_value=Gtk::ListStore.new(String)
$status[0..3].each {|sev|
 iter = sev_ls_value.append
 iter[0] = sev
}

sev_renderer=Gtk::CellRendererCombo.new
column3 = Gtk::TreeViewColumn.new("Severity", sev_renderer, "text" => 2)
column3.set_sort_column_id(2)
sev_renderer.model = sev_ls_value
sev_renderer.text_column = 0
sev_renderer.has_entry = false
sev_renderer.editable = true

def custom_monitor_cell_set_parameter(cell, path_string, new_text, col)
iter = @customview.model.get_iter(path_string)
iter[col] = new_text
	end

tr0 = Gtk::CellRendererText.new
	tr0.editable = true
tr0.mode =Gtk::CellRenderer::MODE_EDITABLE
tr0.signal_connect("edited") { |renderer, iter, var|
custom_monitor_cell_set_parameter(renderer, iter, var, 3) 
	}

column4 = Gtk::TreeViewColumn.new("Parameter", tr0, {:text => 3})
column4.set_sort_column_id(3)

column5 = Gtk::TreeViewColumn.new("Description", renderer, {:text => 4})
column5.visible = false

column1.signal_connect("clicked") do |column|
	toggle_select_custom()
end

sev_renderer.signal_connect("changed") {|cell, path, iter|
    sev = cell.model.get_value(iter,0)
    cell.set_background_gdk(@color_style[$status.index(sev)])
    i = @customview.selection.selected
    @customview.model.set_value(i, 2, sev)
}  

column3.set_cell_data_func(sev_renderer) do |col, renderer, model, iter|
  if iter[2] and iter[2] != ""
    ind = $status.index(iter[2])
    if ind
      color = @color_style[ind]
      if color
        renderer.set_background_gdk(color)
      end
      next
    end
  end
  renderer.background = nil
end

@customview.append_column(column1)
@customview.append_column(column2)
@customview.append_column(column3)
@customview.append_column(column4)
@customview.append_column(column5)
@customview.show

#populate with saved values
if $custom_monitor
   $custom_monitor.each do |cm_name|
   iter = custom_ls.append
   if node.custom_monitoring[cm_name] != nil
    iter[0] = node.custom_monitoring[cm_name].get_state()
   else
    iter[0] = 0
   end		
   #class name
   iter[1] = cm_name
   #default sev
    if node.custom_monitoring[cm_name] != nil
      iter[2] = node.custom_monitoring[cm_name].severity
    else
     begin
       iter[2] = Object.const_get(cm_name).default_severity()
     rescue
       #default sev is not set
       iter[2] = "CRITICAL"
     end
    end
   #param
    if node.custom_monitoring[cm_name] != nil
      iter[3] = node.custom_monitoring[cm_name].param.to_s
    else
      begin
       iter[3] = Object.const_get(cm_name).parameter().to_s
      rescue Exception => msg
        $log.error("Can't instantiate #{cm_name} plugin class #{msg}")
        iter[3] = ""
      end
    end
   #description
    begin
       iter[4] = Object.const_get(cm_name).name()
    rescue Exception => msg
        $log.error("Can't instantiate #{cm_name} plugin class #{msg}")
        iter[4] = ""
    end
  end
end

vbox.add(@customview)

label_custom = Gtk::Label::new("Custom")
notebook_inside.append_page frame, label_custom

###########################end external cmd/plugin monitoring#################################################################
 
	hbox = Gtk::HBox.new(FALSE, 1)
	hbox.add Gtk::Image.new(Gtk::Stock::EXECUTE, Gtk::IconSize::MENU)
	hbox.add Gtk::Label::new("Monitoring")
	hbox.show_all
notebook.append_page notebook_inside, hbox

######################### graph ###################################################################

#  frame = Gtk::Frame::new("Graphic monitoring")
#  frame.border_width=10
#  frame.set_size_request(300, 300)
#  frame.show

#  label = Gtk::Label::new("Graph")
#  notebook.append_page frame, label

###########################end graph#################################################################

 ok_button = Gtk::Button.new(Gtk::Stock::SAVE)
 ok_button.signal_connect("clicked") {

	Thread.kill(@scan_port_th) unless @scan_port_th == nil
	Gtk.thread_flush
	if $config.port_mon
 #store services
 if defined?(@treeview)
  node.clear_service()
   @treeview.model.each {|model, path, iter|
 	   selected = iter[0]
  	   protocol	= iter[1]
  	   port	= iter[2]
  	   service_name	= iter[3]
     sev = iter[4]
     node.add_service(protocol, port, service_name, selected, sev)
  }
  end
	end

#store snmp_monitoring
node.clear_snmp_monitoring()
nbline=0
@snmpview.model.each {|model, path, iter|
  state = iter[0]
  oidname = iter[1]
  oper = iter[2]
  threshold = iter[3]
  severity = iter[4]
  node.add_snmp_monitoring(state, oidname, oper, threshold, severity)
  nbline+=1
}
if nbline > 0 && (node.snmp_sev == UNMANAGED)
  node.set_snmp_severity(UNKNOWN)
end

#store wmi_monitoring
node.clear_wmi_monitoring()
nbline=0
@wmiview.model.each {|model, path, iter|
  state 	= iter[0]
  wminame 	= iter[1]
  oper		= iter[2]
  value= iter[3]
  severity	= iter[4]
  node.add_wmi_monitoring(state, wminame, oper, value, severity)
  nbline+=1
}
if nbline > 0 && (node.snmp_sev == UNMANAGED)
  node.set_snmp_severity(UNKNOWN)
end

	#store jmx_monitoring
	nbline=0
	db_del_jmx_monitoring(node.ip, HOSTNODE)	
	node.jmx_monitoring.each_value { |jmx|		
db_add_jmx_monitoring(node.ip, HOSTNODE, jmx.get_state(), jmx.get_ref(), jmx.get_protocol(), jmx.get_port(), jmx.get_auth(), jmx.get_attributes())
nbline+=1
	}
	if (nbline > 0) && (node.jmx_monitoring.size > 0) && (node.snmp_sev == UNMANAGED)
node.set_snmp_severity(UNKNOWN)
	end

	#store custom_monitoring
	node.clear_custom_monitoring()
	nbline=0
	custom_mon_table = Array.new()

 @customview.model.each {|model, path, iter|
    state = iter[0]
    name = iter[1]
    severity = iter[2]
    param = iter[3]
    custom_mon_table.push(Array.[](state, name,  param, $status.index(severity)))
    nbline+=1
  }
  if nbline > 0
    node.add_custom_monitoring_bulk(custom_mon_table)
  end 

if nbline > 0 && (node.custom_sev == UNMANAGED)
  node.set_custom_severity(UNKNOWN)
end

#store syslog_monitoring
node.clear_syslog_monitoring()
nbline=0
@syslogview.model.each {|model, path, iter|
  state = iter[0]
  syslog_ref 	= iter[1]
  severity	= iter[2]
  node.add_syslog_monitoring(state, syslog_ref, severity)
  nbline+=1
}
if nbline > 0 && (node.trap_sev == UNMANAGED)
  node.set_trap_severity(UNKNOWN)
end

	#store snmptrap_monitoring
	node.clear_snmptrap_monitoring()
	nbline=0
 @snmptrapview.model.each {|model, path, iter|
    		state 		= iter[0]
    		snmptrap_ref	= iter[1]
  	severity	= iter[2]
node.add_snmptrap_monitoring(state, snmptrap_ref, severity)
nbline+=1
	}
	if nbline > 0 && (node.trap_sev == UNMANAGED)
node.set_trap_severity(UNKNOWN)
	end

	#store account only in db as the lived value is already stored in @acccount hash
	node.clear_db_accounts()
	account_table = Array.new()
	@account_view.model.each {|model, path, iter|
 idname     = iter[0]
    	  login		= iter[1]
 password  = iter[2]
 account_table.push([idname, login, password])
	}
	if account_table.length > 0
 node.add_db_account(account_table)
	end


#general
if entry_x.text.to_i >= 0 && entry_x.text.to_i <= $win.window.geometry[2]
  node.x = entry_x.text.to_i
end
if entry_y.text.to_i >= 0 && entry_y.text.to_i <= $win.window.geometry[3]
  node.y = entry_y.text.to_i
end

need_reload_icon=0

if entry_os.name != node.os || entry_type.name != node.type
  need_reload_icon=1
end

if isValidIPv4(entry_ip.text)
  node.ip = entry_ip.text
end

nodeid=db_get_node_id(node.ip, HOSTNODE)

node.netmask = entry_mask.text.to_i
db_set_mask(nodeid, node.netmask)

if (entry_mac.text=="") || (entry_mac.text.match('\s+'))
	node.mac=Node::NOARP_PROPERTY
else
	node.mac = entry_mac.text
end
db_set_mac(nodeid, node.mac)

if (entry_name.text=="") || (entry_name.text.match('\s+'))
	node.dns_name=Node::NONAME_PROPERTY
else
	node.dns_name = entry_name.text
end
if (entry_netbiosname.text=="") || (entry_netbiosname.text.match('\s+'))
	node.netbios_name=Node::NONAME_PROPERTY
else
	node.netbios_name = entry_netbiosname.text
end
if (entry_desc.text=="") || (entry_desc.text.match('\s+'))
	node.description=Node::NODESCR_PROPERTY
else
	node.description = entry_desc.text
end
db_set_description(nodeid, node.description)

node.os = entry_os.name
if entry_type.filename != nil
  node.change_type(entry_type.name)
end
node.change_label()
if need_reload_icon == 1
  node.reload
end

Thread.kill(refresh_node_sev_display)
Gtk.thread_flush
window.destroy
	
	}

	cancel_button = Gtk::Button.new(Gtk::Stock::CANCEL)
	cancel_button.signal_connect("clicked") {
#we rollback the jmx monitoring from the db
node.init_jmx_from_db()
#we rollback here the account from the db to the @account hash
node.init_account_from_db()
Thread.kill(@scan_port_th) unless @scan_port_th == nil
Gtk.thread_flush
Thread.kill(refresh_node_sev_display)
Gtk.thread_flush
window.destroy
	}
	
	hbox=Gtk::HBox.new(FALSE, 10)
	hbox.border_width=10
	hbox.show
	hbox.pack_start(ok_button, TRUE, TRUE, 0)
	ok_button.set_flags(Gtk::Widget::CAN_DEFAULT);
	hbox.pack_start(cancel_button, TRUE, TRUE, 0)
	cancel_button.set_flags(Gtk::Widget::CAN_DEFAULT);
	separator = Gtk::HSeparator::new()
	vboxb.pack_start(separator, FALSE, TRUE, 0)
	separator.show
	vboxb.pack_start(hbox, FALSE, TRUE, 0)
	ok_button.show
	cancel_button.show

	window.show

end

Instance Method Details

#add_monitored_jmx(node, mode = nil) ⇒ `Object`

# File 'lib/gui/node_host_property.rb', line 610

def add_monitored_jmx(node, mode=nil)
	jmxref=nil
	protocol="rmi"
	port=nil
	auth=nil
	jmxattr_h=Hash.new

    addjmxwin=Gtk::Window.new
    addjmxwin.set_icon("#{PIXMAP_PATH}/logo_icon.png")
	 if mode
		 if @jmxview.selection.selected == nil
			return
		 end
		 title="Edit monitored jmx Ref"
		 iter=@jmxview.selection.selected
		 jmxref=iter[1]
		 protocol=iter[2].split("/")[0]
	    	 port=iter[2].split("/")[1]
		 auth=iter[3]
  	 else
		 title="Add monitored jmx Ref"
    end

    addjmxwin.set_title(title)
    addjmxwin.set_size_request(340, 300)
    addjmxwin.set_modal(true)

    addjmxwin.signal_connect("key_press_event") {|w,e|
      if e.keyval == Gdk::Keyval::GDK_Escape
			addjmxwin.destroy
      end
    }

    frame = Gtk::Frame::new
    frame.border_width=10
    frame.show
    vbox_root=Gtk::VBox::new
    vbox_root.show
    addjmxwin.add vbox_root
    vbox_root.add frame
    vbox = Gtk::VBox.new
    vbox.show
    frame.add vbox

    table = Gtk::Table.new(4,2,false)
    table.show

   label_jmxref = Gtk::Label.new "JMX Ref"
   label_jmxref.show
   entry_jmxref = Gtk::ComboBox.new
   if mode 
	entry_jmxref.set_sensitive(false)
   end
   JMXRef::get_jmx_refs_name().each {|ref|
      entry_jmxref.append_text(ref)
   }
   if jmxref
      ind = JMXRef::get_jmx_refs_name().index(jmxref)
      entry_jmxref.set_active(ind) if ind
   else
      entry_jmxref.set_active(0)
   end

   entry_jmxref.set_size_request(150, -1)
   entry_jmxref.show
   bbox=Gtk::HButtonBox.new
   bbox.show
   bbox.add entry_jmxref
   table.attach(label_jmxref,0,1,0,1)
   table.attach(bbox,1,2,0,1)

   entry_protocol = Gtk::Entry.new
   entry_protocol.set_text(protocol) unless protocol==nil
   entry_protocol.set_sensitive(false)
   label_protocol = Gtk::Label.new "Protocol"
   label_protocol.show
   entry_protocol.set_size_request(150, -1)
   entry_protocol.show
   bbox=Gtk::HButtonBox.new
   bbox.show
   bbox.add entry_protocol
   table.attach(label_protocol,0,1,1,2)
   table.attach(bbox,1,2,1,2)

   entry_port = Gtk::Entry.new
   entry_port.set_text(port) unless port==nil
   label_port = Gtk::Label.new "Port"
   label_port.show
   entry_port.set_size_request(150, -1)
   entry_port.show
   bbox=Gtk::HButtonBox.new
   bbox.show
   bbox.add entry_port
   table.attach(label_port,0,1,2,3)
   table.attach(bbox,1,2,2,3)

   label_auth = Gtk::Label.new "Authentication"
   label_auth.show
   entry_auth = Gtk::ComboBox.new
   node.get_all_account().keys.unshift("None").each {|authval|
            entry_auth.append_text(authval)
   }
   if auth
      ind = node.get_all_account().keys.unshift("None").index(auth)
      entry_auth.set_active(ind) if ind
   else
      entry_auth.set_active(0)
   end
   entry_auth.set_size_request(150, -1)
   entry_auth.show
   bbox=Gtk::HButtonBox.new
   bbox.show
   bbox.add entry_auth
   table.attach(label_auth,0,1,3,4)
   table.attach(bbox,1,2,3,4)
 
   jmxls = Gtk::TreeStore.new(String, String, String, String)
   @jmxtv = Gtk::TreeView.new(jmxls)
   @jmxtv_nb_entry=0

	model=Gtk::ListStore.new(String)
	$jmx_refs[entry_jmxref.active_text].attribute.split.each {|attr|
		if attr != ""
			iter = model.append
			iter[0] = attr
		end
	}

	model2=Gtk::ListStore.new(String)
	JmxAttributeMonitoring::TESTOP.each {|op|
		iter = model2.append
		iter[0] = op
	}

	model4=Gtk::ListStore.new(String)
	$status[0..3].each {|sev|
		iter = model4.append
		iter[0] = sev
	}

  renderer1=Gtk::CellRendererCombo.new
  column1 = Gtk::TreeViewColumn.new("Attribute", renderer1, "text" => 0)
  renderer1.model = model
  renderer1.text_column = 0
  renderer1.has_entry = false
  renderer1.editable = true
  renderer1.signal_connect('edited') do |w, path, new_text|
    if path != ""
      iter = @jmxtv.model.get_iter(path)
      iter[0] = new_text
    end
  end
  column1.set_sort_column_id(0)

	renderer2=Gtk::CellRendererCombo.new
	column2 = Gtk::TreeViewColumn.new("Operator", renderer2, "text" => 1)
	column2.set_sort_column_id(1)
	renderer2.model = model2
	renderer2.text_column = 0
  	renderer2.has_entry = false
  	renderer2.editable = true
	renderer2.signal_connect('edited') do |w, path, new_text|
    		if path != ""
			iter = @jmxtv.model.get_iter(path)
        		iter[1] = new_text
			jmxattr_h[iter[0]].set_operator(JmxAttributeMonitoring::TESTOP.index(new_text))
      		end
	end

	def cell_jmx_attr_value_edited(cell, path_string, new_text, col, node, jmxattr_h)
		iter = @jmxtv.model.get_iter(path_string)
		iter[col] = new_text
		jmxattr_h[iter[0]].set_value(new_text)
	end

	tr0=Gtk::CellRendererText.new
	tr0.editable=true
  tr0.mode=Gtk::CellRenderer::MODE_EDITABLE
	tr0.signal_connect("edited") { |renderer, iter, var|
		cell_jmx_attr_value_edited(renderer, iter, var, 2, node, jmxattr_h) 
	}
	column3 = Gtk::TreeViewColumn.new("Value", tr0, "text" => 2)
	column3.set_sort_column_id(2)

  renderer4=Gtk::CellRendererCombo.new
  column4 = Gtk::TreeViewColumn.new("Severity", renderer4, "text" => 3)
  column4.set_sort_column_id(3)
  renderer4.model = model4
  renderer4.text_column = 0
  renderer4.has_entry = false
  renderer4.editable = true
  renderer4.signal_connect('edited') do |w, path, new_text|
    if path != ""
      iter = @jmxtv.model.get_iter(path)
      iter[3] = new_text
      jmxattr_h[iter[0]].set_severity($status.index(new_text))
    end
  end
	
	column4.set_cell_data_func(renderer4) do |col, renderer, model, iter|
	  if iter[3] and iter[3] != ""
	    renderer.set_background_gdk(@color_style[$status.index(iter[3])])
	  else
	    renderer.background = nil
	  end
        end

	@jmxtv.append_column(column1)
	@jmxtv.append_column(column2)
	@jmxtv.append_column(column3)
	@jmxtv.append_column(column4)

	if mode
		#load existing jmx attribute table
		if node.jmx_monitoring[entry_jmxref.active_text]
			attr_h=node.jmx_monitoring[entry_jmxref.active_text].get_attributes()
			attr_h.each_value { |attr|
				parent=jmxls.append(nil)
				parent[0]=attr.attributeName
				parent[1]=JmxAttributeMonitoring::TESTOP[attr.operator]
				parent[2]=attr.value.to_s
				parent[3]=$status[attr.severity]
				jmxattr_h[parent[0]]=JmxAttributeMonitoring.new(parent[0], attr.operator, parent[2], attr.severity)
				@jmxtv_nb_entry+=1
			}
		end
	end
	
	#create menu
	menu_jmx_attr = Gtk::Menu.new

	item_add_jmx_attr = Gtk::ImageMenuItem.new("Add JMX Attribute")
 	image_item_add_jmx_attr = Gtk::Image.new()
 	image_item_add_jmx_attr.set_stock(Gtk::Stock::ADD)
	item_add_jmx_attr.set_image(image_item_add_jmx_attr)
	item_add_jmx_attr.signal_connect("activate") {
		insert_jmx_attr_entry(node, jmxattr_h, entry_jmxref)
	}
	menu_jmx_attr.append(item_add_jmx_attr)

	item_del_jmx_attr = Gtk::ImageMenuItem.new("Delete JMX Attribute")
 	image_item_del_jmx_attr = Gtk::Image.new() 
 	image_item_del_jmx_attr.set_stock(Gtk::Stock::REMOVE) 
	item_del_jmx_attr.set_image(image_item_del_jmx_attr)
	item_del_jmx_attr.signal_connect("activate") {|renderer, iter, var|
		remove_selected_jmx_attr_entry(node, jmxattr_h, entry_jmxref)	
	}
	menu_jmx_attr.append(item_del_jmx_attr)
	menu_jmx_attr.show_all
	
	@jmxtv.signal_connect("button_press_event") do |widget, event|
		if event.kind_of? Gdk::EventButton and event.button == 3
			menu_jmx_attr.popup(nil, nil, event.button, event.time)
		end
	end
		
	@jmxtv.signal_connect("key_press_event") {|w,e|
    		if e.keyval == Gdk::Keyval::GDK_Delete
			remove_selected_jmx_attr_entry(node, jmxattr_h, entry_jmxref)
	    	elsif e.keyval == Gdk::Keyval::GDK_Insert
			insert_jmx_attr_entry(node, jmxattr_h, entry_jmxref)
		end
	}

 	def insert_jmx_attr_entry(node, jmxattr_h, mbean)
		if $jmx_refs[mbean.active_text].attribute.split.size > @jmxtv_nb_entry
			iter=@jmxtv.model.append(nil)
			val=""
			$jmx_refs[mbean.active_text].attribute.split.each {|attr|
				if !jmxattr_h[mbean.active_text]
					val=attr
					break
				elsif !jmxattr_h[attr]
					val=attr
					break
				end
			}
			if val != ""
				#as we insert the attribute we blocked the mbean name
				mbean.set_sensitive(false)
				iter[0] = val
				iter[1] = JmxAttributeMonitoring::TESTOP[0]
				iter[2] = "0"
				iter[3] = $status[0]
				jmxattr_h[iter[0]]=JmxAttributeMonitoring.new(iter[0],0,iter[2],0)
				@jmxtv_nb_entry+=1
			end
		end
  	end
	
	def remove_selected_jmx_attr_entry(node, jmxattr_h, mbean)
		if @jmxtv.selection.selected
		    jmxattr_h.delete(@jmxtv.model.get_value(@jmxtv.selection.selected,0))
		    @jmxtv.model.remove(@jmxtv.selection.selected)
		    @jmxtv_nb_entry-=1
		    if @jmxtv_nb_entry == 0
		       mbean.set_sensitive(true)
		    end
		end
	end
		
    ok_button = Gtk::Button.new(Gtk::Stock::OK)
    ok_button.show
    ok_button.signal_connect("clicked") {
		if (entry_port.text != "") && (isInteger(entry_port.text))
		   if mode
			   #here we just modify this jmx ref
			   iter=@jmxview.selection.selected
			   iter[1] = entry_jmxref.active_text
			   iter[2] = entry_protocol.text + "/" + entry_port.text
			   iter[3] = entry_auth.active_text
			   node.jmx_monitoring[entry_jmxref.active_text].set_protocol(entry_protocol.text)
			   node.jmx_monitoring[entry_jmxref.active_text].set_port(entry_port.text)
			   node.jmx_monitoring[entry_jmxref.active_text].set_auth(entry_auth.active_text)
			   node.jmx_monitoring[entry_jmxref.active_text].clear_attributes()
			   jmxattr_h.each_value {|attr|
				node.jmx_monitoring[entry_jmxref.active_text].add_attribute(attr.attributeName, attr.operator, attr.value, attr.severity)
			   }
     			   addjmxwin.destroy()
		   else
			   #new entry
			   list_rows = 0
			   @jmxtv.model.each {|model, path, it|			   
                           list_rows += 1
			   if  "#{it[2]}" != ""
				   #need to test if already exists
				   error_detected=0
				   @jmxview.model.each {|model, path, iter|
				   if "#{iter[1]}" == "#{entry_jmxref.active_text}"
					   error_detected=1
					   break
				   end
				   }
				   if error_detected == 0
					   iter=@jmxview.model.append
					   iter[0] = 1
					   iter[1] = entry_jmxref.active_text
					   iter[2] = entry_protocol.text + "/" + entry_port.text
					   iter[3] = entry_auth.active_text
					   
					   node.add_jmx_monitoring(iter[0], iter[1], entry_protocol.text, entry_port.text, entry_auth.active_text, jmxattr_h)
    					   addjmxwin.destroy()
				   else
					    errorEntry(addjmxwin, "jmx Ref already set")
				   end
			   else
				   errorEntry(addjmxwin, "jmx Ref, you must set a value")
			   end
			   }
			   errorEntry(addjmxwin, "jmx attributes not set") if list_rows == 0
		   end
		else
			 entry_port.grab_focus()
		         errorEntry(addjmxwin, "Port should be a valid integer")
		end
    }

    cancel_button = Gtk::Button.new(Gtk::Stock::CANCEL)
    cancel_button.show
    cancel_button.signal_connect("clicked") {
  	    addjmxwin.destroy 
    }

	 bbox =Gtk::HBox::new(FALSE, 10)
	 bbox.border_width=10
	 bbox.show

	 ok_button.set_flags(Gtk::Widget::CAN_DEFAULT)
	 bbox.pack_start(ok_button, TRUE, TRUE, 0)
	 cancel_button.set_flags(Gtk::Widget::CAN_DEFAULT)
	 bbox.pack_start(cancel_button, TRUE, TRUE, 0)

	 vbox.add(table)
	 vbox.add(@jmxtv)
	 separator = Gtk::HSeparator::new()
	 separator.show
	 vbox_root.pack_start(separator, FALSE, TRUE, 0)
	 vbox_root.pack_start(bbox, FALSE, TRUE, 0)

    addjmxwin.show_all
end

#add_monitored_service(mode = nil) ⇒ `Object`

add or modify an existing service

# File 'lib/gui/node_host_property.rb', line 40

def add_monitored_service(mode=nil)

 protocol=nil
 port=nil
 service_name=nil
 severity=nil
 
   addportwin=Gtk::Window.new
   addportwin.set_icon("#{PIXMAP_PATH}/logo_icon.png")
 if mode
	 if @treeview.selection.selected == nil
		return
	 end
	 title="Edit monitored service"
	 iter=@treeview.selection.selected
	 protocol=iter[1]
	 port=iter[2]
    service_name=iter[3]
    severity=iter[4]
 	 else
	 title="Add monitored service"
   end

   addportwin.set_title(title)
   addportwin.set_size_request(315, -1)
   addportwin.set_modal(true)

   addportwin.signal_connect("key_press_event") {|w,e|
     if e.keyval == Gdk::Keyval::GDK_Escape
		addportwin.destroy
     end
   }

   frame = Gtk::Frame::new
   frame.border_width=10
   frame.show
   vbox_root=Gtk::VBox::new
   vbox_root.show
   addportwin.add vbox_root
   vbox_root.add frame
   vbox = Gtk::VBox.new
   vbox.show
   frame.add vbox

   table = Gtk::Table.new(4,2,false)
   table.show

   entry_serv = Gtk::Entry.new
   entry_serv.set_text(service_name) unless service_name==nil
   label_proto = Gtk::Label.new "Protocol"
   label_proto.show

 	 entry_proto = Gtk::ComboBox.new
        protos = ["tcp","udp"]
        protos.each {|p|
           entry_proto.append_text(p)
        }
        if protocol
           ind = protos.index(protocol)
           entry_proto.set_active(ind) if ind
        else
           ind = protos.index("tcp")
           entry_proto.set_active(ind) if ind
        end
 entry_proto.set_size_request(20,-1)
 entry_proto.show

 bbox=Gtk::HButtonBox.new
 bbox.show
 bbox.add entry_proto
   table.attach(label_proto,0,1,0,1)
   table.attach(bbox,1,2,0,1)

 label_port = Gtk::Label.new "Port"
 label_port.show
 entry_port = Gtk::Entry.new
 entry_port.set_max_length 5
 entry_port.set_text(port.to_s()) unless port==nil
 entry_port.set_size_request(20,-1)
 entry_port.show
 entry_port.signal_connect("changed") {
	 entry_serv.text=service_name(entry_proto.active_text, entry_port.text)
 }
 entry_proto.signal_connect("changed") {
	 entry_serv.text=service_name(entry_proto.active_text, entry_port.text) unless entry_port.text==nil
 }
 bbox=Gtk::HButtonBox.new
 bbox.show
 bbox.add entry_port
   table.attach(label_port,0,1,1,2)
   table.attach(bbox,1,2,1,2)

   label_serv = Gtk::Label.new "Service"
   label_serv.show
   entry_serv.set_size_request(20,-1)
   entry_serv.show
   bbox=Gtk::HButtonBox.new
   bbox.show
   bbox.add entry_serv
   table.attach(label_serv,0,1,2,3)
   table.attach(bbox,1,2,2,3)

   label_sev = Gtk::Label.new "Severity"
   label_sev.show
   entry_sev = Gtk::ComboBox.new
   $status[0..3].each {|sev|
     entry_sev.append_text(sev)
   }
   entry_sev.signal_connect("changed") {
     entry_sev.child.set_background_gdk(@color_style[entry_sev.active])
   }
  ind = 0
  if severity
     ind = $status[0..3].index(severity)
     entry_sev.set_active(ind) if ind
  else
     entry_sev.set_active(ind)            
  end
  entry_sev.child.set_background_gdk(@color_style[ind])
       
 entry_sev.set_size_request(150,-1)
 entry_sev.show
 bbox=Gtk::HButtonBox.new
 bbox.show
 bbox.add entry_sev
   table.attach(label_sev,0,1,3,4)
   table.attach(bbox,1,2,3,4)

   ok_button = Gtk::Button.new(Gtk::Stock::OK)
   ok_button.show
   ok_button.signal_connect("clicked") {
	if mode
		#here we just modify this service
		if isValidPort(entry_port.text.to_i())		
		  iter=@treeview.selection.selected
		  iter[1] = entry_proto.active_text
		  iter[2] = entry_port.text.to_i
		  iter[3] = entry_serv.text
		  iter[4] = entry_sev.active_text
                         addportwin.destroy()
		else
			errorEntry(addportwin, "Bad port #{entry_port.entry.text}")
		end
	else
		  #just add this service
  	  if isValidPort(entry_port.text.to_i())
		  search_mon_port=false
		  @treeview.model.each {|model, path, iter|
			 if iter[2]==entry_port.text.to_i && iter[1]==entry_proto.active_text
				 search_mon_port=true
				 break
			 end
		  }

		 if search_mon_port==false
			iter=@treeview.model.append
			iter[0] = 1
			iter[1] = entry_proto.active_text
			iter[2] = entry_port.text.to_i
			iter[3] = entry_serv.text
			iter[4] = entry_sev.active_text
     		                addportwin.destroy()
		 else
			 errorEntry(addportwin, "#{entry_proto.active_text}/#{entry_port.text} already exists")
		 end
  	  else 
 	   	  	errorEntry(addportwin, "Bad port #{entry_port.text}")
  	  end
	end
   }

   cancel_button = Gtk::Button.new(Gtk::Stock::CANCEL)
   cancel_button.show
   cancel_button.signal_connect("clicked") {
 	    addportwin.destroy 
   }

 bbox =Gtk::HBox::new(FALSE, 10)
 bbox.border_width=10
 bbox.show

 ok_button.set_flags(Gtk::Widget::CAN_DEFAULT)
 bbox.pack_start(ok_button, TRUE, TRUE, 0)
 cancel_button.set_flags(Gtk::Widget::CAN_DEFAULT)
 bbox.pack_start(cancel_button, TRUE, TRUE, 0)

 vbox.add(table)
 separator = Gtk::HSeparator::new()
 separator.show
 vbox_root.pack_start(separator, FALSE, TRUE, 0)
 vbox_root.pack_start(bbox, FALSE, TRUE, 0)

   addportwin.show

end

#add_monitored_snmp(mode = nil) ⇒ `Object`

# File 'lib/gui/node_host_property.rb', line 236

def add_monitored_snmp(mode=nil)
  oidref=nil
  operator=nil
  threshold=nil
  severity=nil

  addsnmpwin=Gtk::Window.new
  addsnmpwin.set_icon("#{PIXMAP_PATH}/logo_icon.png")
  if mode
    if @snmpview.selection.selected == nil
      return
    end
    title="Edit monitored SNMP OID"
    iter=@snmpview.selection.selected
    oidref=iter[1]
    operator=iter[2]
    threshold=iter[3]
    severity=iter[4]
  else
    title="Add monitored SNMP OID"
  end

  addsnmpwin.set_title(title)
  addsnmpwin.set_size_request(340, -1)
  addsnmpwin.set_modal(true)

  addsnmpwin.signal_connect("key_press_event") {|w,e|
    if e.keyval == Gdk::Keyval::GDK_Escape
      addsnmpwin.destroy
    end
  }

  frame = Gtk::Frame::new
  frame.border_width=10
  frame.show
  vbox_root=Gtk::VBox::new
  vbox_root.show
  addsnmpwin.add vbox_root
  vbox_root.add frame
  vbox = Gtk::VBox.new
  vbox.show
  frame.add vbox

  table = Gtk::Table.new(4,2,false)
  table.show

  label_oidref = Gtk::Label.new "OID Ref"
  label_oidref.show
  entry_oidref = Gtk::ComboBox.new
  OIDRef::get_oid_refs_name().each {|oid|
    entry_oidref.append_text(oid)
  }
  if oidref
    ind = OIDRef::get_oid_refs_name().index(oidref)
    entry_oidref.set_active(ind) if ind
  else
    entry_oidref.set_active(0)
  end
  entry_oidref.set_size_request(150,-1)
  entry_oidref.show
  bbox=Gtk::HButtonBox.new
  bbox.show
  bbox.add entry_oidref
  table.attach(label_oidref,0,1,0,1)
  table.attach(bbox,1,2,0,1)

  label_operator = Gtk::Label.new "Operator"
  label_operator.show
  entry_operator = Gtk::ComboBox.new
  SnmpMonitoring::TESTOP.each {|ope|
    entry_operator.append_text(ope)
  }
  if operator
    ind = SnmpMonitoring::TESTOP.index(operator)
    entry_operator.set_active(ind) if ind
  else
    entry_operator.set_active(0)
  end

  entry_operator.set_size_request(150,-1)
  entry_operator.show
  bbox=Gtk::HButtonBox.new
  bbox.show
  bbox.add entry_operator
  table.attach(label_operator,0,1,1,2)
  table.attach(bbox,1,2,1,2)

  entry_threshold = Gtk::Entry.new
  entry_threshold.set_text(threshold) unless threshold==nil
  label_threshold = Gtk::Label.new "Threshold"
  label_threshold.show
  entry_threshold.set_size_request(150,-1)
  entry_threshold.show
  bbox=Gtk::HButtonBox.new
  bbox.show
  bbox.add entry_threshold
  table.attach(label_threshold,0,1,2,3)
  table.attach(bbox,1,2,2,3)

  label_sev = Gtk::Label.new "Severity"
  label_sev.show
  entry_sev = Gtk::ComboBox.new
  $status[0..3].each {|sev|
    entry_sev.append_text(sev)
  }
  entry_sev.signal_connect("changed") {
    entry_sev.child.set_background_gdk(@color_style[entry_sev.active])
  }
  ind = 0
  if severity
    ind = $status[0..3].index(severity)
    entry_sev.set_active(ind) if ind
  else
    entry_sev.set_active(ind)
  end
  entry_sev.child.set_background_gdk(@color_style[ind])

  entry_sev.set_size_request(150,-1)
  entry_sev.show
  bbox=Gtk::HButtonBox.new
  bbox.show
  bbox.add entry_sev
  table.attach(label_sev,0,1,3,4)
  table.attach(bbox,1,2,3,4)

  ok_button = Gtk::Button.new(Gtk::Stock::OK)
  ok_button.show
  ok_button.signal_connect("clicked") {
    if mode
      #here we just modify this service
      iter=@snmpview.selection.selected
      iter[1] = entry_oidref.active_text
      iter[2] = entry_operator.active_text
      iter[3] = entry_threshold.text
      iter[4] = entry_sev.active_text
      addsnmpwin.destroy()
    else
      if isInteger(entry_threshold.text)
        #need to test if already exists
        error_detected=0
        @snmpview.model.each {|model, path, iter|
          if "#{iter[1]}" == "#{entry_oidref.active_text}"
            error_detected=1
            break
          end
        }
        if error_detected == 0
          iter=@snmpview.model.append
          iter[0] = 1
          iter[1] = entry_oidref.active_text
          iter[2] = entry_operator.active_text
          iter[3] = entry_threshold.text
          iter[4] = entry_sev.active_text
          addsnmpwin.destroy()
        else
          errorEntry(addsnmpwin, "OID Ref already set")
        end
      else
        errorEntry(addsnmpwin, "Threshold #{entry_threshold.text} need to be an integer")
      end
    end
  }

  cancel_button = Gtk::Button.new(Gtk::Stock::CANCEL)
  cancel_button.show
  cancel_button.signal_connect("clicked") {
    addsnmpwin.destroy
  }

  bbox =Gtk::HBox::new(FALSE, 10)
  bbox.border_width=10
  bbox.show

  ok_button.set_flags(Gtk::Widget::CAN_DEFAULT)
  bbox.pack_start(ok_button, TRUE, TRUE, 0)
  cancel_button.set_flags(Gtk::Widget::CAN_DEFAULT)
  bbox.pack_start(cancel_button, TRUE, TRUE, 0)

  vbox.add(table)
  separator = Gtk::HSeparator::new()
  separator.show
  vbox_root.pack_start(separator, FALSE, TRUE, 0)
  vbox_root.pack_start(bbox, FALSE, TRUE, 0)

  addsnmpwin.show
end

#add_monitored_snmptrap(mode = nil) ⇒ `Object`

# File 'lib/gui/node_host_property.rb', line 1001

def add_monitored_snmptrap(mode=nil)
	 snmptrapref=nil
	 severity=nil

	 #list already snmptrap ref configured
	 snmptrap_ref_list=[]

	 if mode
		 if @snmptrapview.selection.selected == nil
			return
		 end
		 title="Edit monitored SNMP Trap Ref"
		 iter=@snmptrapview.selection.selected
		 snmptrapref=iter[1]
		 severity=iter[2]
  	 else
		title="Add monitored SNMP Trap Ref"
		snmptrap_ref_list=get_snmptrap_refs_left()
		if snmptrap_ref_list.size() == 0
			return
		end
    end

    addsnmptrapwin=Gtk::Window.new
    addsnmptrapwin.set_icon("#{PIXMAP_PATH}/logo_icon.png")
    addsnmptrapwin.set_title(title)
    addsnmptrapwin.set_size_request(340, -1)
    addsnmptrapwin.set_modal(true)

    addsnmptrapwin.signal_connect("key_press_event") {|w,e|
      if e.keyval == Gdk::Keyval::GDK_Escape
			addsnmptrapwin.destroy
      end
    }

    frame = Gtk::Frame::new
    frame.border_width=10
    frame.show
    vbox_root=Gtk::VBox::new
    vbox_root.show
    addsnmptrapwin.add vbox_root
    vbox_root.add frame
    vbox = Gtk::VBox.new
    vbox.show
    frame.add vbox

    table = Gtk::Table.new(4,2,false)
    table.show

    label_snmptrapref = Gtk::Label.new "SNMP Trap Ref"
    label_snmptrapref.show
    entry_snmptrapref = Gtk::ComboBox.new
    snmp_trap_list=snmptrap_ref_list
    if mode
	     snmp_trap_list = SnmpTrapRef::get_snmptrap_refs_name()
    end
    snmp_trap_list.each {|slist|
       entry_snmptrapref.append_text(slist)
    }
    if snmptrapref
       ind = snmp_trap_list.index(snmptrapref)
       entry_snmptrapref.set_active(ind) if ind
    else
       entry_snmptrapref.set_active(0)
    end
    entry_snmptrapref.set_size_request(150, -1)
    entry_snmptrapref.show
    bbox=Gtk::HButtonBox.new
    bbox.show
    bbox.add entry_snmptrapref
    table.attach(label_snmptrapref,0,1,0,1)
    table.attach(bbox,1,2,0,1)

    label_sev = Gtk::Label.new "Severity"
    label_sev.show
    entry_sev = Gtk::ComboBox.new
    $status[0..3].each {|sev|
       entry_sev.append_text(sev)
    }
   entry_sev.signal_connect("changed") {
     entry_sev.child.set_background_gdk(@color_style[entry_sev.active])
   }
   ind = 0
   if severity
      ind = $status[0..3].index(severity)
      entry_sev.set_active(ind) if ind
   else
      entry_sev.set_active(ind)            
   end
   entry_sev.child.set_background_gdk(@color_style[ind])
        
    entry_sev.set_size_request(150, -1)
    entry_sev.show
    bbox=Gtk::HButtonBox.new
    bbox.show
    bbox.add entry_sev
    table.attach(label_sev,0,1,1,2)
    table.attach(bbox,1,2,1,2)

    ok_button = Gtk::Button.new(Gtk::Stock::OK)
    ok_button.show
    ok_button.signal_connect("clicked") {
		iter=nil
		if mode
			#here we just modify this service
			iter=@snmptrapview.selection.selected
		else
			iter=@snmptrapview.model.append
			iter[0] = 1
		end
		iter[1] = entry_snmptrapref.active_text
		iter[2] = entry_sev.active_text
                iter[3] = $snmptrap_refs[ entry_snmptrapref.active_text].description
     	addsnmptrapwin.destroy()
    }

    cancel_button = Gtk::Button.new(Gtk::Stock::CANCEL)
    cancel_button.show
    cancel_button.signal_connect("clicked") {
  	    addsnmptrapwin.destroy 
    }

	 bbox =Gtk::HBox::new(FALSE, 10)
	 bbox.border_width=10
	 bbox.show

	 ok_button.set_flags(Gtk::Widget::CAN_DEFAULT)
	 bbox.pack_start(ok_button, TRUE, TRUE, 0)
	 cancel_button.set_flags(Gtk::Widget::CAN_DEFAULT)
	 bbox.pack_start(cancel_button, TRUE, TRUE, 0)

	 vbox.add(table)
	 separator = Gtk::HSeparator::new()
	 separator.show
	 vbox_root.pack_start(separator, FALSE, TRUE, 0)
	 vbox_root.pack_start(bbox, FALSE, TRUE, 0)

    addsnmptrapwin.show
end

#add_monitored_syslog(mode = nil) ⇒ `Object`

# File 'lib/gui/node_host_property.rb', line 1150

def add_monitored_syslog(mode=nil)
  syslogpref=nil
  severity=nil

  #list already syslog ref configured
  syslog_ref_list=[]

  if mode
    if @syslogview.selection.selected == nil
      return
    end
    title="Edit monitored Syslog Ref"
    iter=@syslogview.selection.selected
    syslogpref=iter[1]
    severity=iter[2]
  else
    title="Add monitored Syslog Ref"
    syslog_ref_list=get_syslog_refs_left()
    if syslog_ref_list.size() == 0
      return
    end
  end

  addsyslogwin=Gtk::Window.new
  addsyslogwin.set_icon("#{PIXMAP_PATH}/logo_icon.png")
  addsyslogwin.set_title(title)
  addsyslogwin.set_size_request(340, -1)
  addsyslogwin.set_modal(true)

  addsyslogwin.signal_connect("key_press_event") {|w,e|
    if e.keyval == Gdk::Keyval::GDK_Escape
      addsyslogwin.destroy
    end
  }

  frame = Gtk::Frame::new
  frame.border_width=10
  frame.show
  vbox_root=Gtk::VBox::new
  vbox_root.show
  addsyslogwin.add vbox_root
  vbox_root.add frame
  vbox = Gtk::VBox.new
  vbox.show
  frame.add vbox

  table = Gtk::Table.new(4,2,false)
  table.show

  label_oidref = Gtk::Label.new "Syslog Ref"
  label_oidref.show
  entry_oidref = Gtk::ComboBox.new
  if mode
    syslog_ref_list = SyslogRef::get_syslog_refs_name()
  end

  syslog_ref_list.each {|ref|
    entry_oidref.append_text(ref)
  }
  if syslogpref
    ind = syslog_ref_list.index(syslogpref)
    entry_oidref.set_active(ind) if ind
  else
    entry_oidref.set_active(0)
  end
  entry_oidref.set_size_request(150, -1)
  entry_oidref.show
  bbox=Gtk::HButtonBox.new
  bbox.show
  bbox.add entry_oidref
  table.attach(label_oidref,0,1,0,1)
  table.attach(bbox,1,2,0,1)

  label_sev = Gtk::Label.new "Severity"
  label_sev.show
  entry_sev = Gtk::ComboBox.new
  sevs = [MAP_SYSLOG_SEV]+$status[0..3]
  sevs.each {|sev|
    entry_sev.append_text(sev)
  }
   entry_sev.signal_connect("changed") {
     if entry_sev.active > 0
        entry_sev.child.set_background_gdk(@color_style[entry_sev.active-1])
     end
   }
   ind = 0
   if severity
      ind = sevs.index(severity)
      entry_sev.set_active(ind) if ind
   else
      entry_sev.set_active(ind)            
   end
   if ind > 0
      entry_sev.child.set_background_gdk(@color_style[ind-1])
   end
  
  entry_sev.set_size_request(150, -1)
  entry_sev.show
  bbox=Gtk::HButtonBox.new
  bbox.show
  bbox.add entry_sev
  table.attach(label_sev,0,1,1,2)
  table.attach(bbox,1,2,1,2)

  ok_button = Gtk::Button.new(Gtk::Stock::OK)
  ok_button.show
  ok_button.signal_connect("clicked") {
    iter=nil
    if mode
      #here we just modify this service
      iter=@syslogview.selection.selected
    else
      iter=@syslogview.model.append
      iter[0] = 1
    end
    iter[1] = entry_oidref.active_text
    iter[2] = entry_sev.active_text
    iter[3] = $syslog_refs[entry_oidref.active_text].description
    addsyslogwin.destroy()
  }

  cancel_button = Gtk::Button.new(Gtk::Stock::CANCEL)
  cancel_button.show
  cancel_button.signal_connect("clicked") {
    addsyslogwin.destroy
  }

  bbox =Gtk::HBox::new(FALSE, 10)
  bbox.border_width=10
  bbox.show

  ok_button.set_flags(Gtk::Widget::CAN_DEFAULT)
  bbox.pack_start(ok_button, TRUE, TRUE, 0)
  cancel_button.set_flags(Gtk::Widget::CAN_DEFAULT)
  bbox.pack_start(cancel_button, TRUE, TRUE, 0)

  vbox.add(table)
  separator = Gtk::HSeparator::new()
  separator.show
  vbox_root.pack_start(separator, FALSE, TRUE, 0)
  vbox_root.pack_start(bbox, FALSE, TRUE, 0)

  addsyslogwin.show
end

#add_monitored_wmi(mode = nil) ⇒ `Object`

# File 'lib/gui/node_host_property.rb', line 424

def add_monitored_wmi(mode=nil)
  wmiref=nil
  operator=nil
  value=nil
  severity=nil

  addwmiwin=Gtk::Window.new
  addwmiwin.set_icon("#{PIXMAP_PATH}/logo_icon.png")
  if mode
    if @wmiview.selection.selected == nil
      return
    end
    title="Edit monitored WMI Ref"
    iter=@wmiview.selection.selected
    wmiref=iter[1]
    operator=iter[2]
    value=iter[3]
    severity=iter[4]
  else
    title="Add monitored WMI Ref"
  end

  addwmiwin.set_title(title)
  addwmiwin.set_size_request(340, -1)
  addwmiwin.set_modal(true)

  addwmiwin.signal_connect("key_press_event") {|w,e|
    if e.keyval == Gdk::Keyval::GDK_Escape
      addwmiwin.destroy
    end
  }

  frame = Gtk::Frame::new
  frame.border_width=10
  frame.show
  vbox_root=Gtk::VBox::new
  vbox_root.show
  addwmiwin.add vbox_root
  vbox_root.add frame
  vbox = Gtk::VBox.new
  vbox.show
  frame.add vbox

  table = Gtk::Table.new(4,2,false)
  table.show

  label_wmiref = Gtk::Label.new "WMI Ref"
  label_wmiref.show
  entry_wmiref = Gtk::ComboBox.new
  WMIRef::get_wmi_refs_name().each {|ref|
    entry_wmiref.append_text(ref)
  }
  if wmiref
    ind = WMIRef::get_wmi_refs_name().index(wmiref)
    entry_wmiref.set_active(ind) if ind
  else
    entry_wmiref.set_active(0)
  end
  entry_wmiref.set_size_request(150, -1)
  entry_wmiref.show
  bbox=Gtk::HButtonBox.new
  bbox.show
  bbox.add entry_wmiref
  table.attach(label_wmiref,0,1,0,1)
  table.attach(bbox,1,2,0,1)

  label_operator = Gtk::Label.new "Operator"
  label_operator.show
  entry_operator = Gtk::ComboBox.new
  WmiMonitoring::TESTOP.each {|ope|
    entry_operator.append_text(ope)
  }
  if operator
    ind = WmiMonitoring::TESTOP.index(operator)
    entry_operator.set_active(ind) if ind
  else
    entry_operator.set_active(0)
  end

  entry_operator.set_size_request(150, -1)
  entry_operator.show
  bbox=Gtk::HButtonBox.new
  bbox.show
  bbox.add entry_operator
  table.attach(label_operator,0,1,1,2)
  table.attach(bbox,1,2,1,2)

  entry_value = Gtk::Entry.new
  entry_value.set_text(value) unless value==nil
  label_value = Gtk::Label.new "Value"
  label_value.show
  entry_value.set_size_request(150, -1)
  entry_value.show
  bbox=Gtk::HButtonBox.new
  bbox.show
  bbox.add entry_value
  table.attach(label_value,0,1,2,3)
  table.attach(bbox,1,2,2,3)

  label_sev = Gtk::Label.new "Severity"
  label_sev.show
  entry_sev = Gtk::ComboBox.new
  $status[0..3].each {|sev|
    entry_sev.append_text(sev)
  }
  entry_sev.signal_connect("changed") {
    entry_sev.child.set_background_gdk(@color_style[entry_sev.active])
  }
  ind = 0
  if severity
    ind = $status[0..3].index(severity)
    entry_sev.set_active(ind) if ind
  else
    entry_sev.set_active(ind)
  end
  entry_sev.child.set_background_gdk(@color_style[ind])
  entry_sev.set_size_request(150, -1)
  entry_sev.show
  bbox=Gtk::HButtonBox.new
  bbox.show
  bbox.add entry_sev
  table.attach(label_sev,0,1,3,4)
  table.attach(bbox,1,2,3,4)

  ok_button = Gtk::Button.new(Gtk::Stock::OK)
  ok_button.show
  ok_button.signal_connect("clicked") {
    if mode
      #here we just modify this service
      iter=@wmiview.selection.selected
      iter[1] = entry_wmiref.active_text
      iter[2] = entry_operator.active_text
      iter[3] = entry_value.text
      iter[4] = entry_sev.active_text
      addwmiwin.destroy()
    else
      if entry_value.text != ""
        #need to test if already exists
        error_detected=0
        @wmiview.model.each {|model, path, iter|
          if "#{iter[1]}" == "#{entry_wmiref.active_text}"
            error_detected=1
            break
          end
        }
        if error_detected == 0
          iter=@wmiview.model.append
          iter[0] = 1
          iter[1] = entry_wmiref.active_text
          iter[2] = entry_operator.active_text
          iter[3] = entry_value.text
          iter[4] = entry_sev.active_text
          addwmiwin.destroy()
        else
          errorEntry(addwmiwin, "WMI Ref already set")
        end
      else
        errorEntry(addwmiwin, "WMI Ref, you must set a value")
      end
    end
  }

  cancel_button = Gtk::Button.new(Gtk::Stock::CANCEL)
  cancel_button.show
  cancel_button.signal_connect("clicked") {
    addwmiwin.destroy
  }

  bbox =Gtk::HBox::new(FALSE, 10)
  bbox.border_width=10
  bbox.show

  ok_button.set_flags(Gtk::Widget::CAN_DEFAULT)
  bbox.pack_start(ok_button, TRUE, TRUE, 0)
  cancel_button.set_flags(Gtk::Widget::CAN_DEFAULT)
  bbox.pack_start(cancel_button, TRUE, TRUE, 0)

  vbox.add(table)
  separator = Gtk::HSeparator::new()
  separator.show
  vbox_root.pack_start(separator, FALSE, TRUE, 0)
  vbox_root.pack_start(bbox, FALSE, TRUE, 0)

  addwmiwin.show
end

#cell_jmx_attr_value_edited(cell, path_string, new_text, col, node, jmxattr_h) ⇒ `Object`

# File 'lib/gui/node_host_property.rb', line 779

def cell_jmx_attr_value_edited(cell, path_string, new_text, col, node, jmxattr_h)
	iter = @jmxtv.model.get_iter(path_string)
	iter[col] = new_text
	jmxattr_h[iter[0]].set_value(new_text)
end

#custom_monitor_cell_set_parameter(cell, path_string, new_text, col) ⇒ `Object`

# File 'lib/gui/node_host_property.rb', line 3415

def custom_monitor_cell_set_parameter(cell, path_string, new_text, col)
	iter = @customview.model.get_iter(path_string)
	iter[col] = new_text
end

#edit_monitored_jmx(node) ⇒ `Object`



1307
1308
1309

# File 'lib/gui/node_host_property.rb', line 1307

def edit_monitored_jmx(node)
	add_monitored_jmx(node, "edit")
end

#edit_monitored_service ⇒ `Object`



1295
1296
1297

# File 'lib/gui/node_host_property.rb', line 1295

def edit_monitored_service()
	add_monitored_service("edit")
end

#edit_monitored_snmp ⇒ `Object`



1299
1300
1301

# File 'lib/gui/node_host_property.rb', line 1299

def edit_monitored_snmp()
	add_monitored_snmp("edit")
end

#edit_monitored_snmptrap ⇒ `Object`



1314
1315
1316

# File 'lib/gui/node_host_property.rb', line 1314

def edit_monitored_snmptrap()
	add_monitored_snmptrap("edit")
end

#edit_monitored_syslog ⇒ `Object`



1311
1312
1313

# File 'lib/gui/node_host_property.rb', line 1311

def edit_monitored_syslog()
	add_monitored_syslog("edit")
end

#edit_monitored_wmi ⇒ `Object`



1303
1304
1305

# File 'lib/gui/node_host_property.rb', line 1303

def edit_monitored_wmi()
	add_monitored_wmi("edit")
end

#fill_port_list(node) ⇒ `Object`

# File 'lib/gui/node_host_property.rb', line 1362

def fill_port_list(node)

     #we need to append all monitored ports of service hash
     #@scanned_port_list is ordered as udp first and port number ...
     if node.service != nil
     if @scanned_port_list == nil
		  @scanned_port_list=[]
		  node.service.sort{|s1,s2| s1[0].split('/')[1].to_i()<=>s2[0].split('/')[1].to_i()}.each {|w,serv|
       	  str="#{serv.port} #{serv.protocol} "
			  @scanned_port_list.push "#{str} #{serv.name}"
		  }
	  else
   	 node.service.each_value {|serv|
      	str="#{serv.port} #{serv.protocol} "
      	if !include_regex_str("^#{str}",@scanned_port_list)
      	  # we need to add it correctly
			  plistbis=[]
      	  i=0
      	  for pt in @scanned_port_list
         	 ptt = pt.split(/ /)
         	 if ptt[1] == serv.protocol && serv.port.to_i < ptt[0].to_i
            	plistbis.push "#{str} #{serv.name}"
            	for port in @scanned_port_list[i..@scanned_port_list.size-1]
            	  plistbis.push port
            	end
            	break
         	 else
            	if ptt[1] != serv.protocol
            	  if serv.protocol == "udp"           
	            	 plistbis.push "#{str} #{serv.name}"
               	 for port in @scanned_port_list[i..@scanned_port_list.size-1]
                  	plistbis.push port
               	 end
               	 break
            	  else #its ptt[1] udp the first
               	 plistbis.push pt
            	  end
            	else
            	  plistbis.push pt
            	end
         	 end
         	 i+=1
      	  end
      	  @scanned_port_list=plistbis
		  end
			}
	  end
	end
end

#fill_port_view(node) ⇒ `Object`

# File 'lib/gui/node_host_property.rb', line 1318

def fill_port_view(node)
	@treeview.show
	@vbox_ports.add(@treeview)
	 row_mon_port=[]
	 if @scanned_port_list != nil
   	for x in 1..@scanned_port_list.size
		  row=[]
		  plattr=@scanned_port_list[x-1].split(/[\ ]+/)
		  port=plattr[0].to_i()
		  proto=plattr[1]
		  name=plattr[2]

		  #we verify if we monitor this port
		  cbutton=0
		  if node.is_service_monitor(proto, port)
			  cbutton=1
		  end
		  if name == ""
			  service = "?"
		  else
			  service = name
		  end
		  sev = $status[node.get_service_sev(proto, port)]
		  @cbutton.push(cbutton)
		  row.push(cbutton)			
		  row.push(proto)
		  row.push(port)
		  row.push(service)
		  row.push(sev)
		  row_mon_port.push(row)
	  end
	end
   row_mon_port.each do |cb, proto, port, service, sev|
	  iter = @treeview.model.append
	  iter[0] = cb
	  iter[1] = proto
	  iter[2] = port
	  iter[3] = service
	  iter[4] = sev
	end
end

#get_snmptrap_refs_left ⇒ `Object`

# File 'lib/gui/node_host_property.rb', line 1141

def get_snmptrap_refs_left()
	snmptrap_ref_list=[]
	@snmptrapview.model.each {|model, path, iter|
		snmptrap_ref_list.push(iter[1].dup().to_s())
	}
	snmptrap_ref_list=SnmpTrapRef::get_snmptrap_refs_name()-snmptrap_ref_list
	return snmptrap_ref_list
end

#get_syslog_refs_left ⇒ `Object`

# File 'lib/gui/node_host_property.rb', line 992

def get_syslog_refs_left()
	syslog_ref_list_local=[]
	@syslogview.model.each {|model, path, iter|
		syslog_ref_list_local.push(iter[1].dup().to_s())
	}
	syslog_ref_list_local=SyslogRef::get_syslog_refs_name()-syslog_ref_list_local
	return syslog_ref_list_local
end

#include_regex_str(str, list) ⇒ `Object`

# File 'lib/gui/node_host_property.rb', line 28

def include_regex_str(str,list)
	list.each {|str_lign|
		if str_lign.match(str)
			return true
		end
	} unless list == nil
	return false
end

#insert_jmx_attr_entry(node, jmxattr_h, mbean) ⇒ `Object`

# File 'lib/gui/node_host_property.rb', line 874

def insert_jmx_attr_entry(node, jmxattr_h, mbean)
		if $jmx_refs[mbean.active_text].attribute.split.size > @jmxtv_nb_entry
iter=@jmxtv.model.append(nil)
val=""
$jmx_refs[mbean.active_text].attribute.split.each {|attr|
	if !jmxattr_h[mbean.active_text]
		val=attr
		break
	elsif !jmxattr_h[attr]
		val=attr
		break
	end
}
if val != ""
	#as we insert the attribute we blocked the mbean name
	mbean.set_sensitive(false)
	iter[0] = val
	iter[1] = JmxAttributeMonitoring::TESTOP[0]
	iter[2] = "0"
	iter[3] = $status[0]
	jmxattr_h[iter[0]]=JmxAttributeMonitoring.new(iter[0],0,iter[2],0)
	@jmxtv_nb_entry+=1
end
		end
end

#remove_selected_jmx_attr_entry(node, jmxattr_h, mbean) ⇒ `Object`

# File 'lib/gui/node_host_property.rb', line 900

def remove_selected_jmx_attr_entry(node, jmxattr_h, mbean)
	if @jmxtv.selection.selected
	    jmxattr_h.delete(@jmxtv.model.get_value(@jmxtv.selection.selected,0))
	    @jmxtv.model.remove(@jmxtv.selection.selected)
	    @jmxtv_nb_entry-=1
	    if @jmxtv_nb_entry == 0
	       mbean.set_sensitive(true)
	    end
	end
end

#scan_port_now(node) ⇒ `Object`

scan only one port

# File 'lib/gui/node_host_property.rb', line 1435

def scan_port_now(node)
 if @treeview.selection.selected != nil
   iter = @treeview.selection.selected
   proto = iter[1]
   port = iter[2]
   msgbody = "#{proto.upcase}/#{port} seems down"
   #check if port is up
   if scan_port(node.ip, proto, port) == 1
     msgbody = "#{proto.upcase}/#{port} seems up"
   end
   dialog = Gtk::MessageDialog.new(@window, Gtk::Dialog::MODAL,
                    Gtk::MessageDialog::INFO,
                    Gtk::MessageDialog::BUTTONS_OK,
                    msgbody)
   dialog.set_icon("#{PIXMAP_PATH}/logo_icon.png")
   dialog.signal_connect('response') { dialog.destroy }
   dialog.show
 end
end

#scan_ports_now(node) ⇒ `Object`

scan all ports

# File 'lib/gui/node_host_property.rb', line 1415

def scan_ports_now(node)   
	@scan_port_th=Thread.new {
		labelwait=Gtk::Label.new("Waiting scanning ports ...")
		labelwait.show
		@treeview.hide
		@vbox_ports.remove(@treeview)
		@treeview.model.clear()
		@vbox_ports.add(labelwait)
		@scanned_port_list=listport(node.ip).split(/\n/)
		fill_port_list(node)
		labelwait.hide
		@vbox_ports.remove(labelwait)
		labelwait.destroy
		fill_port_view(node)
 }
end

#snmp_contact(entry, node, read_community) ⇒ `Object`

# File 'lib/gui/node_host_property.rb', line 2111

def snmp_contact(entry, node, read_community)
if $config.snmp_mon
   entry.set_text "(polling...)"
 Thread.start {
  	val=get_snmp_contact(node)
Gtk.thread_protect do
	begin
  			entry.set_position 0
		entry.set_text val
	rescue Exception => msg
		$log.debug("Exception in snmp_contact for #{node.ip}: #{msg}")
	end
end
 }
else
	Gtk.thread_protect do
	begin
		entry.set_sensitive(false)
   		entry.set_text "(SNMP is disable)"
	rescue Exception => msg
		$log.debug("Exception in snmp_contact for #{node.ip}: #{msg}")
	end
end

end
end

#snmp_description(entry, node, read_community) ⇒ `Object`

# File 'lib/gui/node_host_property.rb', line 2029

def snmp_description(entry, node, read_community)
	if $config.snmp_mon		
entry.set_text "(polling...)"
Thread.start {
 		val=get_snmp_description(node)
Gtk.thread_protect do
	begin
	   	entry.set_position 0
		entry.set_text val
	rescue Exception => msg
		$log.debug("Exception in snmp_description for #{node.ip}: #{msg}")
	end
end
 	}
else
Gtk.thread_protect do
		begin
		entry.set_sensitive(false)
	   	entry.set_text "(SNMP is disable)"
	rescue
		$log.debug("Exception in snmp_description for #{node.ip}: #{msg}")		
	end
end
end
end

#snmp_location(entry, node, read_community) ⇒ `Object`

# File 'lib/gui/node_host_property.rb', line 2153

def snmp_location(entry, node, read_community)
if $config.snmp_mon
   entry.set_text "(polling...)"
 Thread.start {
  	val=get_snmp_location(node)
Gtk.thread_protect do
	begin
   		entry.set_position 0
		entry.set_text val
	rescue Exception => msg
		$log.debug("Exception in snmp_location for #{node.ip}: #{msg}")
	end
end
 }
else
Gtk.thread_protect do
		begin
		entry.set_sensitive(false)
	   	entry.set_text "(SNMP is disable)"
	rescue Exception => msg
		$log.debug("Exception in snmp_location for #{node.ip}: #{msg}")
	end
end
end
end

#snmp_uptime(entry, node, read_community) ⇒ `Object`

# File 'lib/gui/node_host_property.rb', line 2071

def snmp_uptime(entry, node, read_community)
if $config.snmp_mon
    entry.set_text "(polling...)"
 Thread.start {
 		val=get_snmp_uptime(node)
Gtk.thread_protect do
	begin
   		entry.set_position 0
		entry.set_text val
	rescue Exception => msg
		$log.debug("Exception in snmp_uptime for #{node.ip}: #{msg}")			
	end
end
 }
else
begin
	entry.set_sensitive(false)
  		entry.set_text "(SNMP is disable)"
rescue Exception => msg
	$log.debug("Exception in snmp_uptime for #{node.ip}: #{msg}")
end
end
end

#toggle_select_custom(path = 0) ⇒ `Object`

# File 'lib/gui/node_host_property.rb', line 20

def toggle_select_custom(path=0)
	 @customview.model.each {|model, path, iter|
      fixed =iter[0]
      fixed ^= 1
      iter[0] = fixed
	}
end

#toggle_select_port(path = 0) ⇒ `Object`

# File 'lib/gui/node_host_property.rb', line 10

def toggle_select_port(path=0)
    #switch all port
	 @treeview.model.each {|model, path, iter|
      fixed =iter[0]
      fixed ^= 1
      @cbutton[path.to_str().to_i()]=fixed
      iter[0] = fixed
	}
end

#wmi_boot(entry, node, login, pass) ⇒ `Object`

# File 'lib/gui/node_host_property.rb', line 2272

def wmi_boot(entry, node, login ,pass)
	if $config.wmi_mon		
entry.set_text "(polling...)"
Thread.start {
 		val=get_wmi_boot_state(login, pass, node.ip)
	if val
		Gtk.thread_protect do
			begin
				entry.set_position 0
				entry.set_text val
			rescue Exception => msg
				$log.debug("Exception in wmi_boot for #{node.ip}: #{msg}")
			end
		end
	end
 	}
else
	Gtk.thread_protect do
 	begin
		entry.set_sensitive(false)
		entry.set_text "(WMI is disable)"
	rescue
	end
end
end
end

#wmi_description(entry, node, login, pass) ⇒ `Object`

# File 'lib/gui/node_host_property.rb', line 2230

def wmi_description(entry, node, login ,pass)
	if $config.wmi_mon		
entry.set_text "(polling...)"
Thread.start {
 		val=get_wmi_description(login, pass, node.ip)
	if val
		Gtk.thread_protect do
			begin
			   	entry.set_position 0
				entry.set_text val
			rescue Exception => msg
				$log.debug("Exception in wmi_description for #{node.ip}: #{msg}")
			end
		end
	end
 	}
else
	begin
	entry.set_sensitive(false)
	entry.set_text "(WMI is disable)"
rescue
end
end
end

#wmi_nbproc(entry, node, login, pass) ⇒ `Object`

# File 'lib/gui/node_host_property.rb', line 2360

def wmi_nbproc(entry, node, login ,pass)
	if $config.wmi_mon		
entry.set_text "(polling...)"
Thread.start {
 		val=get_wmi_nb_proc(login, pass, node.ip)
	if val
		Gtk.thread_protect do
			begin
			   	entry.set_position 0
				entry.set_text val
			rescue Exception => msg
				$log.debug("Exception in wmi_nbproc for #{node.ip}: #{msg}")
			end
		end
	end
 	}
else
	begin
	entry.set_sensitive(false)
	entry.set_text "(WMI is disable)"
rescue
end
end
end

#wmi_os(entry, node, login, pass) ⇒ `Object`

# File 'lib/gui/node_host_property.rb', line 2446

def wmi_os(entry, node, login ,pass)
	if $config.wmi_mon		
entry.set_text "(polling...)"
Thread.start {
 		val=get_wmi_os(login, pass, node.ip)
if val
	Gtk.thread_protect do
		begin
		   	entry.set_position 0
			entry.set_text val
		rescue Exception => msg
			$log.debug("Exception in wmi_os for #{node.ip}: #{msg}")
		end
	end
end
 	}
else
	begin
	entry.set_sensitive(false)
	entry.set_text "(WMI is disable)"
rescue
end
end
end

#wmi_producttype(entry, node, login, pass) ⇒ `Object`

# File 'lib/gui/node_host_property.rb', line 2489

def wmi_producttype(entry, node, login ,pass)
	if $config.wmi_mon		
entry.set_text "(polling...)"
Thread.start {
 		val=get_wmi_product_type(login, pass, node.ip)
if val
	Gtk.thread_protect do
		begin
		   	entry.set_position 0
			entry.set_text val
		rescue Exception => msg
			$log.debug("Exception in wmi_producttype for #{node.ip}: #{msg}")
		end
	end
end
 	}
else
	begin
	entry.set_sensitive(false)
	entry.set_text "(WMI is disable)"
rescue
end
end
end

#wmi_systype(entry, node, login, pass) ⇒ `Object`

# File 'lib/gui/node_host_property.rb', line 2403

def wmi_systype(entry, node, login ,pass)
	if $config.wmi_mon		
entry.set_text "(polling...)"
Thread.start {
 		val=get_wmi_system_type(login, pass, node.ip)
	if val
		Gtk.thread_protect do
			begin
			   	entry.set_position 0
				entry.set_text val
			rescue Exception => msg
				$log.debug("Exception in wmi_systype for #{node.ip}: #{msg}")
			end
		end
	end
 	}
else
	begin
	entry.set_sensitive(false)
	entry.set_text "(WMI is disable)"
rescue
end
end
end

#wmi_thermal(entry, node, login, pass) ⇒ `Object`

# File 'lib/gui/node_host_property.rb', line 2317

def wmi_thermal(entry, node, login ,pass)
	if $config.wmi_mon		
entry.set_text "(polling...)"
Thread.start {
 		val=get_wmi_thermal_state(login, pass, node.ip)
	if val
		Gtk.thread_protect do
			begin
		   		entry.set_position 0
				entry.set_text val
			rescue Exception => msg
				$log.debug("Exception in wmi_thermal for #{node.ip}: #{msg}")
			end
		end
	end
 	}
else
	begin
	entry.set_sensitive(false)
	entry.set_text "(WMI is disable)"
rescue
end
end
end

Class: NodeHostProperty

Instance Method Summary collapse

Constructor Details

#initialize(node) ⇒ NodeHostProperty

Instance Method Details

#add_monitored_jmx(node, mode = nil) ⇒ Object

#add_monitored_service(mode = nil) ⇒ Object

#add_monitored_snmp(mode = nil) ⇒ Object

#add_monitored_snmptrap(mode = nil) ⇒ Object

#add_monitored_syslog(mode = nil) ⇒ Object

#add_monitored_wmi(mode = nil) ⇒ Object

#cell_jmx_attr_value_edited(cell, path_string, new_text, col, node, jmxattr_h) ⇒ Object

#custom_monitor_cell_set_parameter(cell, path_string, new_text, col) ⇒ Object

#edit_monitored_jmx(node) ⇒ Object

#edit_monitored_service ⇒ Object

#edit_monitored_snmp ⇒ Object

#edit_monitored_snmptrap ⇒ Object

#edit_monitored_syslog ⇒ Object

#edit_monitored_wmi ⇒ Object

#fill_port_list(node) ⇒ Object

#fill_port_view(node) ⇒ Object

#get_snmptrap_refs_left ⇒ Object

#get_syslog_refs_left ⇒ Object

#include_regex_str(str, list) ⇒ Object

#insert_jmx_attr_entry(node, jmxattr_h, mbean) ⇒ Object

#remove_selected_jmx_attr_entry(node, jmxattr_h, mbean) ⇒ Object

#scan_port_now(node) ⇒ Object

#scan_ports_now(node) ⇒ Object

#snmp_contact(entry, node, read_community) ⇒ Object

#snmp_description(entry, node, read_community) ⇒ Object

#snmp_location(entry, node, read_community) ⇒ Object

#snmp_uptime(entry, node, read_community) ⇒ Object

#toggle_select_custom(path = 0) ⇒ Object

#toggle_select_port(path = 0) ⇒ Object

#wmi_boot(entry, node, login, pass) ⇒ Object

#wmi_description(entry, node, login, pass) ⇒ Object

#wmi_nbproc(entry, node, login, pass) ⇒ Object

#wmi_os(entry, node, login, pass) ⇒ Object

#wmi_producttype(entry, node, login, pass) ⇒ Object

#wmi_systype(entry, node, login, pass) ⇒ Object

#wmi_thermal(entry, node, login, pass) ⇒ Object

#initialize(node) ⇒ `NodeHostProperty`

#add_monitored_jmx(node, mode = nil) ⇒ `Object`

#add_monitored_service(mode = nil) ⇒ `Object`

#add_monitored_snmp(mode = nil) ⇒ `Object`

#add_monitored_snmptrap(mode = nil) ⇒ `Object`

#add_monitored_syslog(mode = nil) ⇒ `Object`

#add_monitored_wmi(mode = nil) ⇒ `Object`

#cell_jmx_attr_value_edited(cell, path_string, new_text, col, node, jmxattr_h) ⇒ `Object`

#custom_monitor_cell_set_parameter(cell, path_string, new_text, col) ⇒ `Object`

#edit_monitored_jmx(node) ⇒ `Object`

#edit_monitored_service ⇒ `Object`

#edit_monitored_snmp ⇒ `Object`

#edit_monitored_snmptrap ⇒ `Object`

#edit_monitored_syslog ⇒ `Object`

#edit_monitored_wmi ⇒ `Object`

#fill_port_list(node) ⇒ `Object`

#fill_port_view(node) ⇒ `Object`

#get_snmptrap_refs_left ⇒ `Object`

#get_syslog_refs_left ⇒ `Object`

#include_regex_str(str, list) ⇒ `Object`

#insert_jmx_attr_entry(node, jmxattr_h, mbean) ⇒ `Object`

#remove_selected_jmx_attr_entry(node, jmxattr_h, mbean) ⇒ `Object`

#scan_port_now(node) ⇒ `Object`

#scan_ports_now(node) ⇒ `Object`

#snmp_contact(entry, node, read_community) ⇒ `Object`

#snmp_description(entry, node, read_community) ⇒ `Object`

#snmp_location(entry, node, read_community) ⇒ `Object`

#snmp_uptime(entry, node, read_community) ⇒ `Object`

#toggle_select_custom(path = 0) ⇒ `Object`

#toggle_select_port(path = 0) ⇒ `Object`

#wmi_boot(entry, node, login, pass) ⇒ `Object`

#wmi_description(entry, node, login, pass) ⇒ `Object`

#wmi_nbproc(entry, node, login, pass) ⇒ `Object`

#wmi_os(entry, node, login, pass) ⇒ `Object`

#wmi_producttype(entry, node, login, pass) ⇒ `Object`

#wmi_systype(entry, node, login, pass) ⇒ `Object`

#wmi_thermal(entry, node, login, pass) ⇒ `Object`