gnms 2.1.0.rc1

data/lib/monitor/server/syslog/syslog_capture.rb

@@ -0,0 +1,28 @@
+require "#{GNMSLIB}"+'/monitor/server/syslog/syslog_server'
+require "#{GNMSLIB}"+'/monitor/server/msg_buffer'
+require "#{GNMSLIB}"+'/monitor/server/syslog/syslog_analyzer'
+
+class SyslogCapture
+  def initialize()
+	 if $config.syslog_mon
+		buff=MsgBuffer.new(1)
+		begin
+			@input = SyslogServer.new(buff)
+			@output = SyslogAnalyzer.new(buff)
+		rescue Errno::EADDRINUSE => msg
+		rescue Errno::EACCES => msg
+		 $log.error("Syslog Server: not started")
+		end
+	 end
+	end
+
+	def stop()
+		if defined?(@input) && (@input != nil)
+			@input.close_socket()
+			Thread.kill(@input.get_thread())
+			$log.debug("end of SyslogServer thread")
+			#output thread will be done auto
+		end
+	end
+
+end

data/lib/monitor/server/syslog/syslog_monitoring.rb

@@ -0,0 +1,32 @@
+class SyslogMonitoring
+
+   def initialize (st, syslog_ref, sev)
+		@state=st
+	   @syslog_ref=syslog_ref
+		#index of $status, 0 is auto map syslog severity
+	   @severity=sev
+   end
+
+	def get_syslog_ref()
+		return @syslog_ref
+	end
+	
+	def get_state()
+		return @state
+	end
+	
+	def active?()
+		return @state==1
+	end  
+	
+	def raw_severity()
+		return @severity
+	end
+
+	def severity()
+		if @severity > 0
+			return $status[@severity-1]
+		end
+		return nil
+	end
+end #class

data/lib/monitor/server/syslog/syslog_ref.rb

@@ -0,0 +1,136 @@
+class SyslogRef
+   attr_accessor :name, :description
+
+	TABLENAME='syslog_ref'
+#############global management###############
+#
+#	add an syslog_ref
+#	arg n for uniq name, descr the description and calc the calcul to do
+#	return true if deleted otherwise false
+#
+def SyslogRef::add_syslog_ref(n, descr, calc)
+	if $syslog_refs[n] == nil
+		$syslog_refs[n] = SyslogRef.new(n, descr, calc)
+		return true
+	end
+	return false
+end
+
+#
+#	delete an syslog_ref
+#	return true is entry delete otherwise false
+#
+def SyslogRef::del_syslog_ref(n)
+	if !$syslog_refs[n].used?()
+		$syslog_refs.delete(n)
+		return true
+	end
+	return false
+end
+
+def  SyslogRef::write_db_syslogref()
+	if defined?($db) && ($db !=nil)
+		$db.transaction
+		db_delete_all_prp(TABLENAME).execute()
+		stmt=db_insert_ref_prp(TABLENAME)
+		$syslog_refs.each_value do |syslog_ref|
+			stmt.execute(syslog_ref.name, syslog_ref.description, syslog_ref.value.source)
+		end
+		$db.commit
+	end
+end
+
+def SyslogRef::write_syslogref_conf_file(fic_name=SYSLOGREFS_CONF_FILE)
+ 	   field_separator='~'
+  		fic=Tempfile.new(File.basename(fic_name))
+		$syslog_refs.each_value do |syslog_ref|
+			fic.puts "#{syslog_ref.name}#{field_separator}#{syslog_ref.description}#{field_separator}#{syslog_ref.value.source}"
+		end
+		fic.close()
+		if !FileUtils.move(fic.path, fic_name)
+			$log.error("Can not save syslog ref conf file")
+		end
+end
+
+def SyslogRef::read_db_syslogref()
+	if defined?($db) && ($db !=nil)
+		db_select_all_prp(TABLENAME).execute do |rs|
+			rs.each do |name, description, value|
+				add_syslog_ref(name,description,value)
+			end
+		end
+	end
+end
+
+def SyslogRef::read_syslogref_conf_file(fic=SYSLOGREFS_CONF_FILE)
+	field_separator='~'
+	if FileTest.exist?(fic)
+		fic = File.new(fic,'r')
+		lign=fic.gets
+		while lign
+			lign_t = lign.split(field_separator)
+			if lign_t.size() == 3
+				add_syslog_ref(lign_t[0],lign_t[1],lign_t[2].chomp())
+			end
+			lign=fic.gets
+		end
+		fic.close
+	else
+		puts "syslogrefs conf file not found"
+	end
+end
+
+#
+#	return a table of all syslogref name
+#
+def SyslogRef::get_syslog_refs_name()
+	name_t=[]
+	$syslog_refs.each_key {|name|
+		name_t.push name
+	}
+	return name_t
+end
+
+def SyslogRef::syslog_ref_exist?(name)
+	return $syslog_refs[name] != nil
+end
+#############end global management###############
+
+   def initialize (n, descr, re)
+		#name is the identifier, it must be uniq
+      @name=n
+      @description=descr
+		#here value is a regexp
+      @value=Regexp.new(re)
+		@nb_use=0
+	end
+
+	def add_use()
+		@nb_use+=1
+	end
+
+	def del_use()
+		@nb_use-=1
+	end
+
+	def used?()
+		return @nb_use>0 
+	end
+	
+	def to_str()
+		print "SyslogRef: ", @name, " ", @description, " ", @value
+	end
+
+	def get_regex()
+		return @value
+	end
+
+	def value()
+		return @value
+	end
+
+	def set_value(re)
+		 @value=Regexp.new(re)
+	end
+
+end #class

data/lib/monitor/server/syslog/syslog_server.rb

@@ -0,0 +1,43 @@
+class SyslogServer
+
+  def initialize(buff)
+    require 'socket'
+    @port = $config.syslog_port
+    @buff=buff
+    Socket.do_not_reverse_lookup = true
+    @server = UDPSocket.open
+    begin
+      $log.info("Syslog Server: listening on udp port #{@port}")
+      @server.bind("", @port)
+    rescue Errno::EADDRINUSE => msg
+      $log.fatal("Syslog Server: #{msg}, socket in use")
+      raise Errno::EADDRINUSE
+    rescue Errno::EACCES => msg
+      $log.fatal("Syslog Server: #{msg}, need root perms")
+      raise Errno::EACCES
+    rescue Exception => msg
+      raise msg
+    end
+
+    @listener = Thread.start do
+      while $config.syslog_mon
+        begin
+          msg = @server.recvfrom(1024)
+          #extract peer info: domain, port, name, and IP address
+          @buff.put Time.new.to_s()+'|'+"#{msg[1][3]}#{msg[0]}"
+          Thread.pass if @buff.full?
+        rescue Exception => msg
+          #catch when stream is closed by close() method
+        end
+      end
+    end
+  end
+
+  def close_socket()
+    @server.close unless @server == nil
+  end
+
+  def get_thread
+    @listener
+  end
+end

data/lib/node.rb

@@ -0,0 +1,1020 @@
+require "#{GNMSLIB}"+'/gui/color_macro'
+require "#{GNMSLIB}"+'/service'
+require "#{GNMSLIB}"+'/interface'
+
+class Node
+
+  NONAME_PROPERTY="(noname)"
+  NOARP_PROPERTY="(noarp)"
+  NODESCR_PROPERTY="(nodesc)"
+
+  #accessor for inner field
+  attr_accessor :uuid, :ip, :netmask, :ipv6, :netmask6, :service, :custom_monitoring, :snmp_monitoring, :wmi_monitoring, :snmptrap_monitoring, :syslog_monitoring, :jmx_monitoring, :http_monitoring, :status, :interface, :x, :y, :icon, :description, :snmp_version, :snmp_port, :snmp_timeout, :snmp_retry, :type, :os, :node_view, :map
+  attr_reader :avail_sev, :snmp_sev, :custom_sev, :trap_sev, :service_sev, :wmi_sev, :syslog_sev, :jmx_sev
+  #accessor for alert specific reaction
+  attr_accessor :mail_by_level, :sound_file_path_by_level, :sms_num_by_level, :script_name_by_level, :im_dest_by_level
+  attr_accessor :alert_type_by_level, :inherit_from_global
+
+  def set_inherit_conf(bool)
+    @inherit_from_global=bool
+  end
+
+  #
+  #	each time global conf is changed we have to modify the root node config
+  #
+  def set_snmp_conf(rcommunity, wcommunity, version, port, timeout, snmpretry, saveindb_flag=0)
+    if account_exist_nr?("snmp")
+      self.set_account_login("snmp", rcommunity)
+      self.set_account_password("snmp", wcommunity)
+    end
+    @snmp_version=version
+    @snmp_port=port
+    @snmp_timeout=timeout
+    @snmp_retry=snmpretry
+
+    if saveindb_flag
+      nodeid=db_get_node_id(@ip,NETWORKNODE)
+      db_set_snmp_parameter(nodeid, version, port, timeout, snmpretry)
+    end
+  end
+  #
+  #	enable type of alert according to a level
+  #
+  def enable_alert_type(type, level)
+    ind=$talert_type.index(type)
+    if ind > -1
+      set_alert_type(type, level, true)
+      return 0
+    end
+    return 1
+  end
+
+  #
+  #	disable type of alert according to a level
+  #
+  def disable_alert_type(type, level)
+    ind=$talert_type.index(type)
+    if ind > -1
+      set_alert_type(type, level, false)
+      return 0
+    end
+    return 1
+
+  end
+
+  #
+  #	return either the overwritten snmp port or the inherit snmp port from network ancestor
+  #
+  def get_default_inherit_snmp_port()
+    if (self.class == Network) && (@snmp_port != nil)
+      return @snmp_port
+    else
+      if @map == ROOTMAPADDR
+        return $config.snmp_port
+      else
+        return $network[@map].get_default_inherit_snmp_port()
+      end
+    end
+  end
+
+  #
+  #	return either the overwritten snmp version or the default general value
+  #
+  def get_default_inherit_snmp_version()
+    if (self.class == Network) && (@snmp_version != nil)
+      return @snmp_version
+    else
+      if @map == ROOTMAPADDR
+        return $config.snmp_version
+      else
+        return $network[@map].get_default_inherit_snmp_version()
+      end
+    end
+  end
+
+  #
+  #	return either the overwritten snmp timeout or the inherit snmp timeout from network ancestor
+  #
+  def get_default_inherit_snmp_timeout()
+    if (self.class == Network) && (@snmp_timeout != nil)
+      return @snmp_timeout
+    else
+      if @map == ROOTMAPADDR
+        return $config.snmp_timeout
+      else
+        return $network[@map].get_default_inherit_snmp_timeout()
+      end
+    end
+  end
+
+  #
+  #	return either the overwritten snmp retry or the inherit snmp retry from network ancestor
+  #
+  def get_default_inherit_snmp_retry()
+    if (self.class == Network) && (@snmp_retry != nil)
+      return @snmp_retry
+    else
+      if @map == ROOTMAPADDR
+        return $config.snmp_retry
+      else
+        return $network[@map].get_default_inherit_snmp_retry()
+      end
+    end
+  end
+
+
+  def initialize (ip="", mask=24, ipv6="", mask6=64, mp=nil, serv=nil, s=UNKNOWN, xd=0 ,yd=0, i="", d=NODESCR_PROPERTY, t=nil, o="unknown", uuid=create_uuid())
+
+    @uuid = uuid
+    @ip=ip
+    if isInteger(mask)
+      @netmask = mask
+    elsif isValidIPv4(mask)
+      @netmask = IPCalc.netmask_to_bits(mask)
+    end
+    @ipv6=ipv6
+    @netmask6=mask6
+    if serv
+      #serv must be a hash of service class
+      @service=serv.dup
+    else
+      @service=Hash.new
+    end
+
+    @snmp_monitoring=Hash.new
+    @wmi_monitoring=Hash.new
+    @custom_monitoring=Hash.new
+    @syslog_monitoring=Hash.new
+    @snmptrap_monitoring=Hash.new
+    @jmx_monitoring=Hash.new
+    @http_monitoring=Hash.new
+
+    @status=s
+    @avail_sev=UNKNOWN
+    @snmp_sev=UNMANAGED
+    @custom_sev=UNMANAGED
+    @trap_sev=UNMANAGED
+    @service_sev=UNMANAGED
+    @wmi_sev=UNMANAGED
+    @syslog_sev=UNMANAGED
+    @jmx_sev=UNMANAGED
+
+    @account=Hash.new
+    @group=Array.new
+    @interface=Hash.new
+
+    @x=xd
+    @y=yd
+    @links=[]
+    @type=t
+
+    if i == "" || i == nil
+      if $config.host_icon_view=="os"
+        @icon = "os/unknown.png"
+      else
+        #type
+        if (@type != nil) && (@type != "")
+          @icon = "#{find_extension("type/#{@type}")}"
+        end
+      end
+    else
+      @icon=i
+    end
+
+    if d == "" || d == nil
+      @description=""
+    else
+      @description=d
+    end
+
+    @os=o
+    #ip and map could not be the same
+    if mp != ip
+      if mp == nil && ip != ROOTMAPADDR
+        #we want the node on the root network
+        @map=ROOTMAPADDR
+      else
+        if ip == ROOTMAPADDR
+          @map=nil
+          @snmp_version=$config.snmp_version
+          @snmp_port=$config.snmp_port
+          @snmp_timeout=$config.snmp_timeout
+          @snmp_retry=$config.snmp_retry
+        else
+          @map=mp
+          if $network[mp]
+            @snmp_version=$network[mp].snmp_version
+            @snmp_port=$network[mp].snmp_port
+            @snmp_timeout=$network[mp].snmp_timeout
+            @snmp_retry=$network[mp].snmp_retry
+          end
+        end
+      end
+    else
+      @map=ROOTMAPADDR
+    end
+
+    @mail_by_level = Hash.new
+    $config.init_hash_conf_by_level(@mail_by_level)
+    @sound_file_path_by_level = Hash.new
+    $config.init_hash_conf_by_level(@sound_file_path_by_level)
+    @sms_num_by_level = Hash.new
+    $config.init_hash_conf_by_level(@sms_num_by_level)
+    @im_dest_by_level = Hash.new
+    $config.init_hash_conf_by_level(@im_dest_by_level)
+    @script_name_by_level = Hash.new
+    $config.init_hash_conf_by_level(@script_name_by_level)
+
+    @inherit_from_global=true
+    @alert_type_by_level = Hash.new
+    init_level_alert_type(@alert_type_by_level)
+
+  end
+  #
+  #	remove all links between connected nodes
+  #
+  def del_all_links()
+    if nb_links() > 0
+      nb_link=nb_links()
+      cpt=0
+      links_t=@links.dup
+      while cpt < nb_link do
+        lnk=links_t[cpt]
+        lnk.node1.del_link(lnk)
+        lnk.node2.del_link(lnk)
+        $links.delete(lnk)
+        lnk.remove_link()
+        cpt+=1
+      end
+      @links.clear
+    end
+  end
+
+  #
+  #	return links hash
+  #
+  def get_links()
+    return @links
+  end
+
+  #
+  #	return value corresponding to the links between other nodes
+  #
+  def nb_links()
+    return @links.size
+  end
+
+  #
+  #	check if it exists a link between node pass in 1st argument
+  #	return 1 if true or 0 if false
+  #
+  def linked(node)
+    @links.each {|lnk|
+      if lnk.point?(node)
+        return 1
+      end
+    }
+    return 0
+  end
+
+  #
+  #	add a link to links hash
+  #
+  def add_link(lnk)
+    if @links.index(lnk) == nil
+      @links.push(lnk)
+    end
+  end
+
+  #
+  #	del link from links hash between node pass as 1st argument
+  #
+  def del_node_link(node)
+    @links.each {|lnk|
+      if lnk.point?(node)
+        lnk.node1.del_link(lnk)
+        lnk.node2.del_link(lnk)
+        $links.delete(lnk)
+        lnk.remove_link()
+        return 1
+      end
+    }
+    return 0
+  end
+
+  #
+  #	del link from links hash pass in 1st argument
+  #
+  def del_link(lnk)
+    @links.delete(lnk)
+  end
+
+  #
+  #	update status based on the avail, snmp, custom severities
+  #
+  def refresh_status()
+    $log.debug("refresh_status: #{ip} status=#{@status}")
+    #if all sev are identical, set general sev as sev
+    if @avail_sev ==  @snmp_sev and @snmp_sev == @custom_sev and @custom_sev == @trap_sev and @trap_sev == @service_sev and @service_sev == @wmi_sev and @wmi_sev == @syslog_sev and @syslog_sev == @jmx_sev
+      change_status(@snmp_sev)
+      if @snmp_sev == UNMANAGED and self.node_view
+        self.node_view.reset_notification()
+        self.node_view.update_notification_icon()
+      end
+      return
+    end
+
+    #reinit specific sev if needed
+    if !$config.port_mon and (@service_sev != UNMANAGED)
+      @service_sev = UNMANAGED
+    end
+    if !$config.snmp_mon and (@snmp_sev != UNMANAGED)
+      @snmp_sev  = UNMANAGED
+    end
+    if !$config.custom_mon and (@custom_sev != UNMANAGED)
+      @custom_sev  = UNMANAGED
+    end
+    if !$config.snmptrap_mon and (@trap_sev != UNMANAGED)
+      @trap_sev  = UNMANAGED
+    end
+    if !$config.syslog_mon and (@syslog_sev != UNMANAGED)
+      @syslog_sev  = UNMANAGED
+    end
+    if !$config.wmi_mon and (@wmi_sev != UNMANAGED)
+      @wmi_sev  = UNMANAGED
+    end
+    if !$config.jmx_mon and (@jmx_sev != UNMANAGED)
+      @jmx_sev  = UNMANAGED
+    end
+
+    if $config.port_mon and (@service_sev == UNMANAGED)
+      @service_sev = UNKNOWN
+    end
+    if $config.snmp_mon and (@snmp_sev == UNMANAGED)
+      @snmp_sev  = UNKNOWN
+    end
+    if $config.custom_mon and (@custom_sev == UNMANAGED)
+      @custom_sev  = UNKNOWN
+    end
+    if $config.snmptrap_mon and (@trap_sev == UNMANAGED)
+      @trap_sev  = UNKNOWN
+    end
+    if $config.syslog_mon and (@syslog_sev == UNMANAGED)
+      @syslog_sev  = UNKNOWN
+    end
+    if $config.wmi_mon and (@wmi_sev == UNMANAGED)
+      @wmi_sev  = UNKNOWN
+    end
+    if $config.jmx_mon and (@jmx_sev == UNMANAGED)
+      @jmx_sev  = UNKNOWN
+    end
+
+    #if at least one is critical set global sev to critical
+    if ((@avail_sev == CRITICAL) and (@snmp_sev <= UNMANAGED) and (@custom_sev <= UNMANAGED) and (@trap_sev <= UNMANAGED) and (@service_sev <= UNMANAGED) and (@wmi_sev <= UNMANAGED) and (@syslog_sev <= UNMANAGED) and (@jmx_sev <= UNMANAGED)) || (@snmp_sev == CRITICAL) || (@custom_sev == CRITICAL) || (@trap_sev == CRITICAL) || (@service_sev == CRITICAL) || (@jmx_sev == CRITICAL) || (@syslog_sev == CRITICAL) || (@wmi_sev == CRITICAL)
+      change_status(CRITICAL)
+    else
+      if ((@avail_sev > UNMANAGED) and (@snmp_sev <= UNMANAGED) and (@custom_sev <= UNMANAGED) and (@trap_sev <= UNMANAGED) and (@service_sev <= UNMANAGED) and (@wmi_sev <= UNMANAGED) and (@syslog_sev <= UNMANAGED) and (@jmx_sev <= UNMANAGED))
+        change_status(@avail_sev)
+      else
+        #we have to dont care about UNMANAGED and UNKNOWN value
+        cpt=0
+        if @snmp_sev > UNMANAGED
+          cpt+=1
+        end
+        if @custom_sev > UNMANAGED
+          cpt+=1
+        end
+        if @trap_sev > UNMANAGED
+          cpt+=1
+        end
+        if @service_sev > UNMANAGED
+          cpt+=1
+        end
+        if @wmi_sev > UNMANAGED
+          cpt+=1
+        end
+        if @syslog_sev > UNMANAGED
+          cpt+=1
+        end
+        if @jmx_sev > UNMANAGED
+          cpt+=1
+        end
+
+        if cpt > 0
+          val=(
+          (((@service_sev>UNMANAGED) and $config.port_mon)?@service_sev:UNMANAGED) +
+          (((@snmp_sev>UNMANAGED) and $config.snmp_mon)?@snmp_sev:UNMANAGED) +
+          (((@wmi_sev>UNMANAGED) and $config.wmi_mon)?@wmi_sev:UNMANAGED) +
+          (((@jmx_sev>UNMANAGED) and $config.jmx_mon)?@jmx_sev:UNMANAGED) +
+          (((@custom_sev>UNMANAGED) and $config.custom_mon)?@custom_sev:UNMANAGED) +
+          (((@trap_sev>UNMANAGED) and $config.snmptrap_mon)?@trap_sev:UNMANAGED) +
+          (((@syslog_sev>UNMANAGED) and $config.syslog_mon)?@syslog_sev:UNMANAGED)
+          )/cpt
+
+          #print "cpt: ",cpt, " val ",val.floor(),"\n"
+          if val.floor() <= UNMANAGED
+            $log.fatal("refresh_status: fail to compute status")
+          else
+            change_status(val.floor())
+          end
+        end
+      end
+    end
+  end
+
+  def hide_label()
+    @node_view.hide_text()
+  end
+
+  def show_label()
+    @node_view.show_text() unless !@node_view
+  end
+
+  def set_label_visibility()
+    if !$config.show_label
+      hide_label()
+      return false
+    else
+      show_label()
+      return true
+    end
+  end
+
+  def set_severity(event_type, sev)
+    case event_type
+    when EventWindow::PORT_EVENT_TYPE
+      set_service_severity(sev)
+    when EventWindow::TRAP_EVENT_TYPE
+      set_trap_severity(sev)
+    when EventWindow::CUSTOM_EVENT_TYPE
+      set_custom_severity(sev)
+    when EventWindow::SNMP_EVENT_TYPE
+      set_snmp_severity(sev)
+    when EventWindow::WMI_EVENT_TYPE
+      set_wmi_severity(sev)
+    when EventWindow::SYSLOG_EVENT_TYPE
+      set_syslog_severity(sev)
+    when EventWindow::JMX_EVENT_TYPE
+      set_jmx_severity(sev)
+    when EventWindow::AVAIL_EVENT_TYPE
+      set_avail_severity(sev)
+    when EventWindow::CORE_EVENT_TYPE
+    else
+      $log.error("unknown event type: #{event_type}")
+    end
+  end
+
+  def set_avail_severity(sev)
+    @avail_sev=sev
+    refresh_status()
+  end
+
+  def set_service_severity(sev)
+    @service_sev=sev
+    refresh_status()
+  end
+
+  def set_wmi_severity(sev)
+    @wmi_sev=sev
+    refresh_status()
+  end
+
+  def set_jmx_severity(sev)
+    @jmx_sev=sev
+    refresh_status()
+  end
+
+  def set_syslog_severity(sev)
+    @syslog_sev=sev
+    refresh_status()
+  end
+
+
+  #sev is an index $status_value
+  def set_snmp_severity(sev)
+    @snmp_sev=sev
+    refresh_status()
+  end
+
+  def set_custom_severity(sev)
+    @custom_sev=sev
+    refresh_status()
+  end
+
+  #use for snmp trap and syslog msgs
+  def set_trap_severity(sev)
+    @trap_sev=sev
+    refresh_status()
+  end
+
+  def set_all_severity(sev)
+    @avail_sev=sev
+    @snmp_sev=sev
+    @custom_sev=sev
+    @trap_sev=sev
+    @service_sev=sev
+    @wmi_sev=sev
+    @syslog_sev=sev
+    @jmx_sev=sev
+    refresh_status()
+  end
+
+  # return custom monitoring severity
+  def custom_severity(name)
+    cust = @custom_monitoring[name]
+    if cust
+      return cust.severity
+    end
+    return nil
+  end
+  
+  # return custom monitoring parameter
+  def custom_parameter(name)
+    cust = @custom_monitoring[name]
+    if cust
+      return cust.param
+    end
+    return nil
+  end
+  
+  def service_key(protocol, port)
+    return "#{protocol}/#{port}"
+  end
+ 
+  # return service instance based on the service name as a key
+  def service_by_name(name)
+    @service.each_value {|serv|
+       if serv.name == name
+          return serv
+       end
+    }
+    return nil
+  end
+  
+  def add_service(protocol, port, name="?", monitor_flag=1, sev=0)
+    if @service[service_key(protocol, port)] == nil
+      @service[service_key(protocol, port)] = Service.new(protocol,port,name,monitor_flag,$status.index(sev))
+    end
+    #store in db
+    db_add_service(ip, get_node_type(), protocol, port, name, monitor_flag, $status.index(sev))
+  end
+
+  def del_service(protocol, port)
+    if @service[service_key(protocol, port)] != nil
+      @service[service_key(protocol, port)].delete()
+    end
+    #del in db
+    db_del_service(protocol, port)
+  end
+
+  #
+  #	check if a given port is monitored
+  #
+  def is_service_monitor(protocol, port)
+    return (@service[service_key(protocol, port)] != nil) && (@service[service_key(protocol, port)].monitored?())
+  end
+
+  #
+  #	get severity associated to a given proto/port
+  #
+  def get_service_sev(protocol, port)
+    return @service[service_key(protocol, port)].severity
+  end
+
+
+  def add_wmi_monitoring(state, wmiref_name, op, val, sev, status=nil)
+    if @wmi_monitoring[wmiref_name] == nil
+      if WMIRef::wmi_ref_exist?(wmiref_name)
+        if sev.class != Fixnum
+          @wmi_monitoring[wmiref_name]=WmiMonitoring.new(state, wmiref_name, WmiMonitoring::TESTOP.index(op), val, $status.index(sev))
+          db_add_wmi_monitoring(ip, get_node_type(), state, wmiref_name, WmiMonitoring::TESTOP.index(op), val, $status.index(sev)) unless status
+        else
+          @wmi_monitoring[wmiref_name]=WmiMonitoring.new(state, wmiref_name, op, val, sev)
+          db_add_wmi_monitoring(ip, get_node_type(), state, wmiref_name, op, val, sev) unless status
+        end
+        $wmi_refs[wmiref_name].add_use()
+      else
+        $log.error("WMI entry #{wmiref_name} is unknown")
+      end
+    end
+  end
+
+  def add_jmx_monitoring(state, jmxref_name, proto, port, auth, attribuesh)
+    if @jmx_monitoring[jmxref_name] == nil
+      if JMXRef::jmx_ref_exist?(jmxref_name)
+        @jmx_monitoring[jmxref_name]=JmxMonitoring.new(state, jmxref_name, proto, port, auth)
+        attribuesh.each_value {|attr|
+          if attr.class == JmxAttributeMonitoring
+            @jmx_monitoring[jmxref_name].add_attribute(attr.attributeName, attr.operator, attr.value, attr.severity)
+          end
+        }
+        $jmx_refs[jmxref_name].add_use()
+      else
+        $log.error("JMX entry #{jmxref_name} is unknown")
+      end
+    end
+  end
+
+  def add_snmp_monitoring(state, oidref_name, op, val, sev, status=nil)
+    if @snmp_monitoring[oidref_name] == nil
+      if OIDRef::oid_ref_exist?(oidref_name)
+        if sev.class != Fixnum
+          @snmp_monitoring[oidref_name]=SnmpMonitoring.new(state, oidref_name, SnmpMonitoring::TESTOP.index(op), val, $status.index(sev))
+          db_add_snmp_monitoring(ip, get_node_type(), state, oidref_name, SnmpMonitoring::TESTOP.index(op), val, $status.index(sev)) unless status
+        else
+          @snmp_monitoring[oidref_name]=SnmpMonitoring.new(state, oidref_name, op, val, sev)
+          db_add_snmp_monitoring(ip, get_node_type(), state, oidref_name, op, val, sev) unless status
+        end
+        $oid_refs[oidref_name].add_use()
+      else
+        $log.error("SNMP OID #{oidref_name} is unknown")
+      end
+    end
+  end
+
+  def nb_interface()
+    return @interface.size
+  end
+
+  def add_interface(n, lstatus=nil, sp=nil, tp=nil)
+    if @interface[n] == nil
+      @interface[n] = Interface.new(n, lstatus, sp, tp)
+      #we are adding it in db at save time
+    else
+      $log.error("Interface #{n} already exists")
+    end
+  end
+
+  def del_interface(n)
+    if @interface[n] != nil
+      @interface[n].delete()
+    end
+  end
+
+  def del_wmi_monitoring(oidref_name)
+    if @wmi_monitoring[oidref_name] != nil
+      $wmi_refs[oidref_name].del_use()
+      @wmi_monitoring[oidref_name].delete()
+    end
+  end
+
+  def del_jmx_monitoring(oidref_name)
+    if @jmx_monitoring[oidref_name] != nil
+      $jmx_refs[oidref_name].del_use()
+      @jmx_monitoring[oidref_name].delete()
+    end
+  end
+
+  def del_snmp_monitoring(oidref_name)
+    if @snmp_monitoring[oidref_name] != nil
+      $oid_refs[oidref_name].del_use()
+      @snmp_monitoring[oidref_name].delete()
+    end
+  end
+
+  def add_custom_monitoring(state, custom_mon_name, param, sev, status=nil)
+    if $custom_monitor and ($custom_monitor.index(custom_mon_name) != nil) and (@custom_monitoring[custom_mon_name] == nil)
+      @custom_monitoring[custom_mon_name] = CustomMonitoring.new(state.to_i, custom_mon_name, param, sev.to_i)
+      db_add_custom_monitoring(ip, get_node_type(), [state, custom_mon_name, param, sev]) unless status      
+    end
+  end
+
+  def add_custom_monitoring_bulk(custom_mon_array)
+    custom_mon_array.each {|state, custom_mon_name, param, sev|
+      add_custom_monitoring(state.to_i, custom_mon_name, param, sev.to_i, "init")
+    }
+    db_add_custom_monitoring(ip, get_node_type(), custom_mon_array)
+  end
+
+  def del_custom_monitoring(custom_mon_name)
+    if @custom_monitoring[custom_mon_name] != nil
+       @custom_monitoring[custom_mon_name].delete()
+    end
+  end
+
+  def add_syslog_monitoring(state, syslog_ref_name, sev, status=nil)
+    if @syslog_monitoring[syslog_ref_name] == nil
+      if SyslogRef::syslog_ref_exist?(syslog_ref_name)
+        if sev.class != Fixnum
+          #puts "add_syslog_monitoring ", syslog_ref_name, sev, $status.index(sev)
+          #here 0 sev corresponds to map syslog default severity
+          sev_tmp=$status.index(sev)
+          if sev_tmp == nil
+            sev_tmp=0
+          else
+            sev_tmp+=1
+          end
+          @syslog_monitoring[syslog_ref_name]=SyslogMonitoring.new(state, syslog_ref_name, sev_tmp)
+          db_add_syslog_monitoring(ip, get_node_type(), state, syslog_ref_name , sev_tmp) unless status
+        else
+          #puts "add_syslog_monitoring ", syslog_ref_name, sev
+          @syslog_monitoring[syslog_ref_name]=SyslogMonitoring.new(state, syslog_ref_name, sev)
+          db_add_syslog_monitoring(ip, get_node_type(), state, syslog_ref_name , sev) unless status
+        end
+        $syslog_refs[syslog_ref_name].add_use()
+      end
+    end
+  end
+
+  def del_syslog_monitoring(syslog_ref_name)
+    if @syslog_monitoring[syslog_ref_name] != nil
+      $syslog_refs[syslog_ref_name].del_use()
+      @syslog_monitoring[syslog_ref_name].delete()
+    end
+  end
+
+  def add_snmptrap_monitoring(state, snmptrap_ref_name, sev, status=nil)
+    if @snmptrap_monitoring[snmptrap_ref_name] == nil
+      if SnmpTrapRef::snmptrap_ref_exist?(snmptrap_ref_name)
+        if sev.class != Fixnum
+          sev_tmp=$status.index(sev)
+          if sev_tmp == nil
+            sev_tmp=0
+          else
+            sev_tmp+=1
+          end
+          @snmptrap_monitoring[snmptrap_ref_name]=SnmpTrapMonitoring.new(state, snmptrap_ref_name, sev_tmp)
+          db_add_snmptrap_monitoring(ip, get_node_type(), state, snmptrap_ref_name, sev_tmp) unless status
+        else
+          @snmptrap_monitoring[snmptrap_ref_name]=SnmpTrapMonitoring.new(state, snmptrap_ref_name, sev)
+          db_add_snmptrap_monitoring(ip, get_node_type(), state, snmptrap_ref_name, sev) unless status
+        end
+        $snmptrap_refs[snmptrap_ref_name].add_use()
+      end
+    end
+  end
+
+  def del_snmptrap_monitoring(snmptrap_ref_name)
+    if @snmptrap_monitoring[snmptrap_ref_name] != nil
+      $snmptrap_refs[snmptrap_ref_name].del_use()
+      @snmptrap_monitoring[snmptrap_ref_name].delete()
+    end
+  end
+
+  #
+  #	set map for changing map of a node
+  #
+  def set_map(map)
+    if map != @map
+      if self.class == Host
+        $network[@map].del_host(ip)
+        $network[@map].update_status()
+        @map=map
+        $network[@map].add_host(self)
+        $network[@map].update_status()
+        @node_view.reparent($network[@map].map_view)
+      else
+        $network[@map].del_net(ip)
+        $network[@map].update_status()
+        @map=map
+        $network[@map].add_network(self)
+        $network[@map].update_status()
+        @node_view.reparent($network[@map].map_view)
+      end
+    end
+  end
+
+  #
+  #	clear all accounts from the hash
+  #
+  def clear_account()
+    @account=Hash.new
+  end
+
+  #
+  #	clear all accounts from *db*
+  #
+  def clear_db_accounts()
+    db_del_accounts(ip, get_node_type())
+  end
+
+  #
+  #	add account in *db*
+  #
+  def add_db_account(accounts)
+    db_add_account(ip, get_node_type(), accounts)
+  end
+
+  #
+  #	clear all services
+  #
+  def clear_service()
+    @service=Hash.new
+    db_del_services(ip, get_node_type())
+  end
+
+  #
+  #	clear all wmi monitoring
+  #
+  def clear_wmi_monitoring()
+    @wmi_monitoring.each_value do |wmi_mon|
+      $wmi_refs[wmi_mon.wmiref].del_use()
+    end
+    @wmi_monitoring=Hash.new
+    db_del_wmi_monitoring(ip, get_node_type())
+  end
+
+  #
+  #	clear all jmx monitoring
+  #
+  def clear_jmx_monitoring()
+    @jmx_monitoring.each_value do |jmx_mon|
+      $jmx_refs[jmx_mon.get_ref()].del_use()
+    end
+    @jmx_monitoring=Hash.new
+    db_del_jmx_monitoring(ip, get_node_type())
+  end
+
+  def init_jmx_from_db()
+    @jmx_monitoring.each_value do |jmx_mon|
+      $jmx_refs[jmx_mon.get_ref()].del_use()
+    end
+    @jmx_monitoring=Hash.new
+    db_get_jmx_monitoring(ip, get_node_type())
+  end
+
+  def get_node_type()
+    nodetype=HOSTNODE
+    if self.class == Network
+      nodetype=NETWORKNODE
+    end
+    return nodetype
+  end
+
+  #
+  #	clear all snmp monitoring
+  #
+  def clear_snmp_monitoring()
+    @snmp_monitoring.each_value do |snmp_mon|
+      $oid_refs[snmp_mon.oidref].del_use()
+    end
+    @snmp_monitoring=Hash.new
+    db_del_snmp_monitoring(ip, get_node_type())
+  end
+
+  #
+  #	clear all custom monitoring
+  #
+  def clear_custom_monitoring()
+    @custom_monitoring=Hash.new
+    db_del_custom_monitoring(ip, get_node_type())
+  end
+
+  #
+  #	clear all snmptrap monitoring
+  #
+  def clear_snmptrap_monitoring()
+    @snmptrap_monitoring.each_value do |snmptrap_mon|
+      $snmptrap_refs[snmptrap_mon.get_snmptrap_ref()].del_use()
+    end
+    @snmptrap_monitoring=Hash.new
+    db_del_snmptrap_monitoring(ip, get_node_type())
+  end
+
+  #
+  #	clear all syslog monitoring
+  #
+  def clear_syslog_monitoring()
+    @syslog_monitoring.each_value do |syslog_mon|
+      $syslog_refs[syslog_mon.get_syslog_ref()].del_use()
+    end
+    @syslog_monitoring=Hash.new
+    db_del_syslog_monitoring(ip, get_node_type())
+  end
+
+
+  #
+  #	return description if different from default value
+  #
+  def description?()
+    return description != "(nodesc)"
+  end
+
+  #
+  #	return a point corresponding to the position of the node
+  #
+  def point_pos()
+    return [@x, @y]
+  end
+
+  #
+  # check if a given account id already exist
+  #
+  def account_size()
+    return @account.size()
+  end
+
+  #
+  # get the accounts hash
+  #
+  def get_all_account()
+    return @account
+  end
+
+  #
+  # set the accounts hash
+  #
+  def set_all_account(haccount)
+    @account=haccount.dup
+  end
+
+  #
+  # set the interface hash
+  #
+  def set_all_interface(intf)
+    @interface=intf.dup
+  end
+
+
+  #
+  # init account from db
+  #
+  def init_account_from_db()
+    clear_account()
+    @account=db_get_accounts(ip, get_node_type())
+  end
+
+  #
+  # get the account idents
+  #
+  def get_account_id(id)
+    if account_exist_nr?(id)
+      return @account[id]
+    end
+    return $network[@map].get_all_account()[id]
+  end
+
+  #
+  # get the account login specify by id
+  #
+  def get_account_login(id)
+    return @account[id][0]
+  end
+
+  #
+  # set the account login specify by id
+  #
+  def set_account_login(id, value)
+    @account[id][0]=value
+  end
+
+  #
+  # get the account password specify by id
+  #
+  def get_account_password(id)
+    return @account[id][1]
+  end
+
+  #
+  # set the account password specify by id
+  #
+  def set_account_password(id, value)
+    @account[id][1]=value
+  end
+
+  #
+  # check if a given account id already exist
+  #
+  def account_exist?(id)
+    if !@map
+      return @account.has_key?(id)
+    end
+    #account can also be the account from the network
+    return @account.has_key?(id) || $network[@map].get_all_account().has_key?(id)
+  end
+
+  #
+  # check if a given account id already exist for the host (non recursive)
+  #
+  def account_exist_nr?(id)
+    return @account.has_key?(id)
+  end
+
+  #
+  # add an account
+  #
+  def add_account(id, login, passwd)
+    if !account_exist_nr?(id)
+      @account[id] = Array.new(2)
+      @account[id][0] = login
+      @account[id][1] = passwd
+    end
+  end
+
+  #
+  # del an account
+  #
+  def del_account(id)
+    return @account.delete(id)
+  end
+
+  #
+  #	set type value property based on level
+  #
+  private
+  def set_alert_type(type, level, value)
+    @alert_type_by_level[level][$talert_type.index(type)]=value
+  end
+  alias ipv4 ip
+  alias netmask4 netmask
+end #class