netsnmp 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d6bb62b9abd416188660e04be1c12cf009b1df0e307030b9c239ea4b2acd73cc
-  data.tar.gz: ee88f7eb292f1a0077ab25e4677713290447e0e7755049bbe6db50f07d15d6a1
+  metadata.gz: b080e928ed8014ae935e3bafd2356c21304b60f1c29c2c5327f7694e2825567a
+  data.tar.gz: de052efcd0958285cf8ae5609fadca6519d94e48af2076f74d1a76886e6f5309
 SHA512:
-  metadata.gz: fc90cc626d4be2a04d598ec267bcfc108e87aea8e8a585a7611033fc56cb6c174a222250bb9eeeb05b2d03d058983b106c92c30ba3d91e922b171ecfbc37041a
-  data.tar.gz: '09dbbb277ae24d9b760c0de70738a02037da527d653d5e003632c1b41d808cc21c44034fb51bec63394a132fe3c30ffaac1adc846dc061ca483e13fc0719af97'
+  metadata.gz: 9ead6354c915b389219ef88a0227fe509347897b4980278cd4daf08d410014effeb1863c2d4aa36ddcc019c9dd018f9ec383771812e50de75ed3f6d29d35fd38
+  data.tar.gz: 323eb76b9ed6538704897d000b03d100c04b3443dd2b7c6b2313da67db065a0adca5f31431eef0b571eb9a29a4d9762fd6151fc90840c149cdf023634ab802d3

data/README.md

@@ -55,6 +55,7 @@ All of these issues are resolved here.
 
 * Client Interface, which supports SNMP v3, v2c, and v1
 * Supports get, getnext, set and walk calls.
+* MIB support.
 * Proxy IO object support (for eventmachine/celluloid-io)
 * Ruby >= 2.1 support (modern)
 * Pure Ruby (no FFI)
@@ -73,12 +74,11 @@ manager = NETSNMP::Client.new(host: "localhost", port: 33445, username: "simulat
                               context: "a172334d7d97871b72241397f713fa12")
 
 # SNMP get
-# sysName.0
-manager.get(oid: "1.3.6.1.2.1.1.0") #=> 'tt'
+manager.get(oid: "sysName.0") #=> 'tt'
 
 # SNMP walk
 # sysORDescr
-manager.walk(oid: "1.3.6.1.2.1.1.1").each do |oid_code, value|
+manager.walk(oid: "sysORDescr").each do |oid_code, value|
   # do something with them  
   puts "for #{oid_code}: #{value}"
 end
@@ -135,6 +135,29 @@ manager.set("somecounteroid", value: 999999, type: 6)
 ```
 * Fork this library, extend support, write a test and submit a PR (the desired solution ;) )
 
+## MIB
+
+`netsnmp` will load the default MIBs from known or advertised (via `MIBDIRS`) directories (provided that they're installed in the system). These will be used for the OID conversion.
+
+Sometimes you'll need to load more, your own MIBs, in which case, you can use the following API:
+
+```ruby
+require "netsnmp"
+
+NETSNMP::MIB.load("MY-MIB")
+# or, if it's not in any of the known locations
+NETSNMP::MIB.load("/path/to/MY-MIB.txt")
+```
+
+You can install common SNMP mibs by using your package manager:
+
+```
+# using apt-get
+> apt-get install snmp-mibs-downloader
+# using apk
+> apk --update add net-snmp-libs
+```
+
 ## Concurrency
 
 In ruby, you are usually adviced not to share IO objects across threads. The same principle applies here to `NETSNMP::Client`: provided you use it within a thread of execution, it should behave safely. So, something like this would be possible:
@@ -272,7 +295,6 @@ The job of the CI is:
 
 There are some features which this gem doesn't support. It was built to provide a client (or manager, in SNMP language) implementation only, and the requirements were fulfilled. However, these notable misses will stand-out:
 
-* No MIB support (you can only work with OIDs)
 * No server (Agent, in SNMP-ish) implementation.
 * No getbulk support.
 

data/lib/netsnmp.rb

@@ -34,6 +34,17 @@ rescue LoadError
 end
 
 module NETSNMP
+  module IsNumericExtensions
+    refine String do
+      def integer?
+        each_byte do |byte|
+          return false unless byte >= 48 && byte <= 57
+        end
+        true
+      end
+    end
+  end
+
   module StringExtensions
     # If you wonder why this is there: the oauth feature uses a refinement to enhance the
     # Regexp class locally with #match? , but this is never tested, because ActiveSupport
@@ -73,6 +84,7 @@ require "netsnmp/timeticks"
 require "netsnmp/oid"
 require "netsnmp/varbind"
 require "netsnmp/pdu"
+require "netsnmp/mib"
 require "netsnmp/session"
 
 require "netsnmp/scoped_pdu"

data/lib/netsnmp/client.rb

@@ -77,7 +77,7 @@ module NETSNMP
     # @return [Enumerator] the enumerator-collection of the oid-value pairs
     #
     def walk(oid:)
-      walkoid = oid
+      walkoid = OID.build(oid)
       Enumerator.new do |y|
         code = walkoid
         first_response_code = nil

data/lib/netsnmp/mib.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require_relative "mib/parser"
+
+module NETSNMP
+  module MIB
+    using IsNumericExtensions
+
+    OIDREGEX = /^[\d\.]*$/
+
+    module_function
+
+    MIBDIRS = ENV.fetch("MIBDIRS", File.join("/usr", "share", "snmp", "mibs")).split(":")
+    PARSER = Parser.new
+    @parser_mutex = Mutex.new
+    @modules_loaded = []
+    @object_identifiers = {}
+
+    # Translates na identifier, such as "sysDescr", into an OID
+    def oid(identifier)
+      prefix, *suffix = case identifier
+                        when Array
+                          identifier
+                        else
+                          identifier.split(".", 2)
+                        end
+
+      # early exit if it's an OID already
+      unless prefix.integer?
+        load_defaults
+        # load module if need be
+        idx = prefix.index("::")
+        if idx
+          mod = prefix[0..(idx - 1)]
+          type = prefix[(idx + 2)..-1]
+          return unless load(mod)
+        else
+          type = prefix
+        end
+
+        return if type.nil? || type.empty?
+
+        prefix = @object_identifiers[type] ||
+                 raise(Error, "can't convert #{type} to OID")
+
+      end
+
+      [prefix, *suffix].join(".")
+    end
+
+    # This is a helper function, do not rely on this functionality in future
+    # versions
+    def identifier(oid)
+      @object_identifiers.select do |_, full_oid|
+        full_oid.start_with?(oid)
+      end
+    end
+
+    #
+    # Loads a MIB. Can be called multiple times, as it'll load it once.
+    #
+    # Accepts the MIB name in several ways:
+    #
+    #     MIB.load("SNMPv2-MIB")
+    #     MIB.load("SNMPv2-MIB.txt")
+    #     MIB.load("/path/to/SNMPv2-MIB.txt")
+    #
+    def load(mod)
+      unless File.file?(mod)
+        moddir = nil
+        MIBDIRS.each do |mibdir|
+          if File.exist?(File.join(mibdir, mod))
+            moddir = File.join(mibdir, mod)
+            break
+          elsif File.extname(mod).empty? && File.exist?(File.join(mibdir, "#{mod}.txt"))
+            moddir = File.join(mibdir, "#{mod}.txt")
+            break
+          end
+        end
+        return false unless moddir
+        mod = moddir
+      end
+      return true if @modules_loaded.include?(mod)
+      do_load(mod)
+      @modules_loaded << mod
+      true
+    end
+
+    TYPES = ["OBJECT-TYPE", "OBJECT IDENTIFIER", "MODULE-IDENTITY"].freeze
+
+    STATIC_MIB_TO_OID = {
+      "iso" => "1"
+    }.freeze
+
+    #
+    # Loads the MIB all the time, where +mod+ is the absolute path to the MIB.
+    #
+    def do_load(mod)
+      data = @parser_mutex.synchronize { PARSER.parse(File.read(mod)) }
+
+      imports = load_imports(data)
+
+      data[:declarations].each_with_object(@object_identifiers) do |dec, types|
+        next unless TYPES.include?(dec[:type])
+
+        oid = String(dec[:value]).split(/ +/).flat_map do |cp|
+          if cp.integer?
+            cp
+          else
+            STATIC_MIB_TO_OID[cp] || @object_identifiers[cp] || begin
+              imported_mod, = imports.find do |_, identifiers|
+                identifiers.include?(cp)
+              end
+
+              raise Error, "didn't find a module to import \"#{cp}\" from" unless imported_mod
+
+              load(imported_mod)
+
+              @object_identifiers[cp]
+            end
+          end
+        end.join(".")
+
+        types[String(dec[:name])] = oid
+      end
+    end
+
+    #
+    # Reformats the import lists into an hash indexed by module name, to a list of
+    # imported names
+    #
+    def load_imports(data)
+      return unless data[:imports]
+
+      data[:imports].each_with_object({}) do |import, imp|
+        imp[String(import[:name])] = case import[:ids]
+                                     when Hash
+                                       [String(import[:ids][:name])]
+                                     else
+                                       import[:ids].map { |id| String(id[:name]) }
+                                     end
+      end
+    end
+
+    def load_defaults
+      # loading the defaults MIBS
+      load("SNMPv2-MIB")
+      load("IF-MIB")
+    end
+  end
+end

data/lib/netsnmp/mib/parser.rb

@@ -0,0 +1,750 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module NETSNMP::MIB
+  class Parser < Parslet::Parser
+    root :mibfile
+
+    def spaced(character = nil)
+      if character.nil? && block_given?
+        yield >> space.repeat
+      else
+        str(character) >> space.repeat
+      end
+    end
+
+    def curly(atom)
+      str("{") >> space.repeat >> atom >> space.repeat >> str("}")
+    end
+
+    def bracketed(atom)
+      str("(") >> space.repeat >> atom >> space.repeat >> str(")")
+    end
+
+    def square_bracketed(atom)
+      str("[") >> space.repeat >> atom >> space.repeat >> str("]")
+    end
+
+    def with_separator(atom, separator = nil)
+      if separator
+        sep = if separator.is_a?(String)
+                space.repeat >> str(separator) >> space.repeat
+              else
+                separator
+              end
+
+        atom >> (sep >> atom).repeat
+      else
+        atom >> (space.repeat >> atom).repeat
+      end
+    end
+
+    rule(:mibfile) do
+      space.repeat >> modules.maybe
+    end
+
+    rule(:modules) do
+      with_separator(mod)
+    end
+
+    rule(:mod) do
+      spaced { module_name.as(:name) } >> module_oid >>
+        spaced("DEFINITIONS") >> colon_colon_part >>
+        spaced("BEGIN") >>
+        exports_part.as(:exports) >>
+        linkage_part.as(:imports) >>
+        declaration_part.as(:declarations) >>
+        spaced("END")
+    end
+
+    rule(:module_name) { uppercase_identifier }
+
+    rule(:module_oid) do
+      spaced { curly(object_identifier) }.maybe
+    end
+
+    rule(:declaration_part) do
+      spaced { declarations }.maybe
+    end
+
+    rule(:exports_part) do
+      spaced { exports_clause }.maybe
+    end
+
+    rule(:exports_clause) do
+      spaced("EXPORTS") >> spaced { import_identifiers } >> str(";")
+    end
+
+    rule(:linkage_part) do
+      spaced { linkage_clause }.maybe
+    end
+
+    rule(:linkage_clause) do
+      spaced("IMPORTS") >> spaced { import_part } >> str(";")
+    end
+
+    rule(:import_part) do
+      imports.maybe
+    end
+
+    rule(:imports) { with_separator(import) }
+
+    rule(:import) do
+      spaced { import_identifiers.as(:ids) } >> spaced("FROM") >> module_name.as(:name)
+    end
+
+    rule(:import_identifiers) { with_separator(import_identifier.as(:name), ",") }
+
+    rule(:import_identifier) do
+      lowercase_identifier | uppercase_identifier | imported_keyword
+    end
+
+    rule(:imported_keyword) do
+      imported_smi_keyword |
+        str("BITS") |
+        str("Integer32")  |
+        str("IpAddress")  |
+        str("MANDATORY-GROUPS") |
+        str("MODULE-COMPLIANCE") |
+        str("MODULE-IDENTITY") |
+        str("OBJECT-GROUP") |
+        str("OBJECT-IDENTITY") |
+        str("OBJECT-TYPE") |
+        str("Opaque") |
+        str("TEXTUAL-CONVENTION") |
+        str("TimeTicks") |
+        str("Unsigned32")
+    end
+
+    rule(:imported_smi_keyword) do
+      str("AGENT-CAPABILITIES") |
+        str("Counter32") |
+        str("Counter64") |
+        str("Gauge32") |
+        str("NOTIFICATION-GROUP") |
+        str("NOTIFICATION-TYPE") |
+        str("TRAP-TYPE")
+    end
+
+    rule(:declarations) do
+      with_separator(declaration)
+    end
+
+    rule(:declaration) do
+      type_declaration |
+        value_declaration |
+        object_identity_clause |
+        object_type_clause |
+        traptype_clause |
+        notification_type_clause |
+        module_identity_clause |
+        module_compliance_clause |
+        object_group_clause |
+        notification_group_clause |
+        agent_capabilities_clause |
+        macro_clause
+    end
+
+    rule(:macro_clause) do
+      spaced { macro_name.as(:name) } >> spaced { str("MACRO").as(:type) } >> colon_colon_part >>
+        spaced("BEGIN") >>
+        # ignoring macro clauses
+        match("^(?!END)").repeat >>
+        spaced("END")
+    end
+
+    rule(:macro_name) do
+      str("MODULE-IDENTITY") |
+        str("OBJECT-TYPE") |
+        str("TRAP-TYPE") |
+        str("NOTIFICATION-TYPE") |
+        str("OBJECT-IDENTITY") |
+        str("TEXTUAL-CONVENTION") |
+        str("OBJECT-GROUP") |
+        str("NOTIFICATION-GROUP") |
+        str("MODULE-COMPLIANCE") |
+        str("AGENT-CAPABILITIES")
+    end
+
+    rule(:agent_capabilities_clause) do
+      spaced { lowercase_identifier.as(:name) } >>
+        spaced { str("AGENT-CAPABILITIES").as(:type) } >>
+        spaced("PRODUCT-RELEASE") >> spaced { text } >>
+        spaced("STATUS") >> spaced { status } >>
+        spaced("DESCRIPTION") >> spaced { text } >>
+        spaced { refer_part }.maybe >>
+        spaced { module_part_capabilities }.maybe >>
+        colon_colon_part >> curly(object_identifier)
+    end
+
+    rule(:module_part_capabilities) do
+      modules_capabilities
+    end
+
+    rule(:modules_capabilities) do
+      with_separator(module_capabilities)
+    end
+
+    rule(:module_capabilities) do
+      spaced("SUPPORTS") >>
+        module_name_capabilities >>
+        spaced("INCLUDES") >> curly(capabilities_groups) >>
+        spaced { variation_part }.maybe
+    end
+
+    rule(:module_name_capabilities) do
+      spaced { uppercase_identifier } >> object_identifier | uppercase_identifier
+    end
+
+    rule(:capabilities_groups) do
+      with_separator(capabilities_group)
+    end
+
+    rule(:capabilities_group) { objectIdentifier }
+
+    rule(:variation_part) do
+      variations
+    end
+
+    rule(:variations) do
+      with_separator(variation)
+    end
+
+    rule(:variation) do
+      spaced("VARIATION") >> object_identifier >>
+        spaced { syntax_part }.maybe >>
+        spaced { write_syntax_part } >>
+        spaced { variation_access_part }.maybe >>
+        spaced { creation_part }.maybe >>
+        spaced { def_val_part }.maybe >>
+        spaced("DESCRIPTION") >> text
+    end
+
+    rule(:variation_access_part) do
+      spaced("ACCESS") >> variation_access
+    end
+
+    rule(:variation_access) { lowercase_identifier }
+
+    rule(:creation_part) do
+      spaced("CREATION-REQUIRES") >> curly(cells)
+    end
+
+    rule(:cells) { with_separator(cell, ",") }
+
+    rule(:cell) { object_identifier }
+
+    rule(:notification_group_clause) do
+      spaced { lowercase_identifier.as(:name) } >>
+        spaced { str("NOTIFICATION-GROUP").as(:type) } >>
+        spaced { notifications_part } >>
+        spaced("STATUS") >> spaced { status } >>
+        spaced("DESCRIPTION") >> spaced { text } >>
+        spaced { refer_part }.maybe >>
+        colon_colon_part >> curly(object_identifier)
+    end
+
+    rule(:notifications_part) do
+      spaced("NOTIFICATIONS") >> curly(notifications)
+    end
+
+    rule(:notifications) do
+      with_separator(notification, ",")
+    end
+
+    rule(:notification) do
+      notification_name
+    end
+
+    rule(:object_group_clause) do
+      spaced { lowercase_identifier.as(:name) } >>
+        spaced { str("OBJECT-GROUP").as(:type) } >>
+        spaced { object_group_objects_part } >>
+        spaced("STATUS") >> spaced { status } >>
+        spaced("DESCRIPTION") >> spaced { text } >>
+        spaced { refer_part }.maybe >>
+        colon_colon_part >> curly(object_identifier)
+    end
+
+    rule(:object_group_objects_part) do
+      spaced("OBJECTS") >> curly(objects)
+    end
+
+    rule(:module_compliance_clause) do
+      spaced { lowercase_identifier.as(:name) } >>
+        spaced { str("MODULE-COMPLIANCE").as(:type) } >>
+        spaced("STATUS") >> spaced { status } >>
+        spaced("DESCRIPTION") >> spaced { text } >>
+        spaced { refer_part }.maybe >>
+        spaced { compliance_modules } >>
+        colon_colon_part >> curly(object_identifier)
+    end
+
+    rule(:compliance_modules) do
+      with_separator(compliance_module)
+    end
+
+    rule(:compliance_module) do
+      spaced { str("MODULE") >> (space_in_line.repeat(1) >> compliance_module_name).maybe } >>
+        spaced { mandatory_part }.maybe >>
+        compliances.maybe
+    end
+
+    rule(:compliance_module_name) do
+      uppercase_identifier
+    end
+
+    rule(:mandatory_part) do
+      spaced("MANDATORY-GROUPS") >> curly(mandatory_groups)
+    end
+
+    rule(:compliances) do
+      with_separator(compliance).as(:compliances)
+    end
+
+    rule(:compliance) do
+      compliance_group | compliance_object
+    end
+
+    rule(:compliance_group) do
+      spaced { str("GROUP").as(:type) } >> spaced { object_identifier.as(:name) } >>
+        spaced("DESCRIPTION") >> text
+    end
+
+    rule(:compliance_object) do
+      spaced { str("OBJECT").as(:type) } >>
+        spaced { object_identifier.as(:name) } >>
+        spaced { syntax_part }.maybe >>
+        spaced { write_syntax_part }.maybe >>
+        spaced { access_part }.maybe >>
+        spaced("DESCRIPTION") >> text
+    end
+
+    rule(:syntax_part) do
+      spaced("SYNTAX") >> syntax.as(:syntax)
+    end
+
+    rule(:write_syntax_part) do
+      (spaced("WRITE-SYNTAX") >> spaced { syntax }).maybe
+    end
+
+    rule(:access_part) do
+      (spaced("MIN-ACCESS") >> spaced { access }).maybe
+    end
+
+    rule(:mandatory_groups) do
+      with_separator(mandatory_group, ",").as(:groups)
+    end
+
+    rule(:mandatory_group) { object_identifier.as(:name) }
+
+    rule(:module_identity_clause) do
+      spaced { lowercase_identifier.as(:name) } >>
+        spaced { str("MODULE-IDENTITY").as(:type) } >>
+        (spaced("SUBJECT-CATEGORIES") >> curly(category_ids)).maybe >>
+        spaced("LAST-UPDATED") >> spaced { ext_utc_time } >>
+        spaced("ORGANIZATION") >> spaced { text.as(:organization) } >>
+        spaced("CONTACT-INFO") >> spaced { text.as(:contact_info) } >>
+        spaced("DESCRIPTION") >> spaced { text } >>
+        spaced { revisions }.maybe >>
+        colon_colon_part >> curly(object_identifier.as(:value))
+    end
+
+    rule(:ext_utc_time) { text }
+
+    rule(:revisions) do
+      with_separator(revision)
+    end
+
+    rule(:revision) do
+      spaced("REVISION") >> spaced { ext_utc_time } >>
+        spaced("DESCRIPTION") >>
+        text
+    end
+
+    rule(:category_ids) do
+      with_separator(category_id, ",")
+    end
+
+    rule(:category_id) do
+      spaced { lowercase_identifier } >> bracketed(number) | lowercase_identifier
+    end
+
+    rule(:notification_type_clause) do
+      spaced { lowercase_identifier.as(:name) } >>
+        spaced { str("NOTIFICATION-TYPE").as(:type) } >>
+        spaced { notification_objects_part }.maybe >>
+        spaced("STATUS") >> spaced { status } >>
+        spaced("DESCRIPTION") >> spaced { text } >>
+        spaced { refer_part }.maybe >>
+        colon_colon_part >> curly(notification_name)
+    end
+
+    rule(:notification_objects_part) do
+      spaced("OBJECTS") >> curly(objects)
+    end
+
+    rule(:objects) do
+      with_separator(object, ",")
+    end
+
+    rule(:object) do
+      object_identifier
+    end
+
+    rule(:notification_name) do
+      object_identifier
+    end
+
+    rule(:traptype_clause) do
+      spaced { fuzzy_lowercase_identifier.as(:name) } >>
+        spaced { str("TRAP-TYPE").as(:type) } >> spaced { enterprise_part } >>
+        spaced { var_part }.maybe >>
+        spaced { descr_part }.maybe >>
+        spaced { refer_part }.maybe >>
+        colon_colon_part >> number
+    end
+
+    rule(:enterprise_part) do
+      spaced("ENTERPRISE") >> object_identifier |
+        spaced("ENTERPRISE") >> curly(object_identifier)
+    end
+
+    rule(:var_part) do
+      spaced("VARIABLES") >> curly(var_types)
+    end
+
+    rule(:var_types) do
+      with_separator(var_type, ",")
+    end
+
+    rule(:var_type) { object_identifier }
+
+    rule(:descr_part) do
+      spaced("DESCRIPTION") >> text
+    end
+
+    rule(:object_type_clause) do
+      spaced { lowercase_identifier.as(:name) } >>
+        spaced { str("OBJECT-TYPE").as(:type) } >>
+        spaced { syntax_part }.maybe >>
+        spaced { units_part }.maybe >>
+        spaced { max_access_part }.maybe >>
+        (spaced("STATUS") >> spaced { status }).maybe >>
+        spaced { description_clause }.maybe >>
+        spaced { refer_part }.maybe >>
+        spaced { index_part }.maybe >>
+        spaced { mib_index }.maybe >>
+        spaced { def_val_part }.maybe >>
+        colon_colon_part >> curly(object_identifier.as(:value))
+    end
+
+    rule(:object_identity_clause) do
+      spaced { lowercase_identifier.as(:name) } >>
+        spaced { str("OBJECT-IDENTITY").as(:type) } >>
+        spaced("STATUS") >> spaced { status } >>
+        spaced("DESCRIPTION") >> spaced { text } >>
+        spaced { refer_part }.maybe >>
+        colon_colon_part >> curly(object_identifier)
+    end
+
+    rule(:units_part) do
+      spaced("UNITS") >> text.as(:units)
+    end
+
+    rule(:max_access_part) do
+      spaced("MAX-ACCESS") >> access | spaced("ACCESS") >> access
+    end
+
+    rule(:access) { lowercase_identifier }
+
+    rule(:description_clause) do
+      spaced("DESCRIPTION") >> text
+    end
+
+    rule(:index_part) do
+      spaced("AUGMENTS") >> curly(entry)
+    end
+
+    rule(:mib_index) do
+      spaced("INDEX") >> curly(index_types)
+    end
+
+    rule(:def_val_part) do
+      spaced("DEFVAL") >> curly(valueof_simple_syntax)
+    end
+
+    rule(:valueof_simple_syntax) do
+      value | lowercase_identifier | text | curly(object_identifiers_defval)
+    end
+
+    rule(:object_identifiers_defval) do
+      with_separator(object_identifier_defval)
+    end
+
+    rule(:object_identifier_defval) do
+      spaced { lowercase_identifier } >> bracketed(number) |
+        number
+    end
+
+    rule(:index_types) do
+      with_separator(index_type, ",")
+    end
+
+    rule(:index_type) do
+      spaced("IMPLIED") >> idx | idx
+    end
+
+    rule(:idx) do
+      object_identifier
+    end
+
+    rule(:entry) do
+      object_identifier
+    end
+
+    rule(:value_declaration) do
+      spaced { fuzzy_lowercase_identifier.as(:name) } >>
+        spaced { str("OBJECT IDENTIFIER").as(:type) } >>
+        colon_colon_part >> curly(object_identifier.as(:value))
+    end
+
+    rule(:fuzzy_lowercase_identifier) do
+      lowercase_identifier | uppercase_identifier
+    end
+
+    rule(:object_identifier) do
+      sub_identifiers
+    end
+
+    rule(:sub_identifiers) do
+      with_separator(sub_identifier, space_in_line.repeat)
+    end
+
+    rule(:sub_identifier) do
+      fuzzy_lowercase_identifier |
+        number |
+        spaced { lowercase_identifier } >> bracketed(number)
+    end
+
+    rule(:type_declaration) do
+      spaced { type_name.as(:vartype) } >> colon_colon_part >> type_declaration_rhs
+    end
+
+    rule(:type_name) do
+      uppercase_identifier | type_smi
+    end
+
+    rule(:type_smi) do
+      type_smi_and_sppi | type_smi_only
+    end
+
+    rule(:type_declaration_rhs) do
+      spaced { choice_clause } |
+        spaced { str("TEXTUAL-CONVENTION") } >>
+        spaced { display_part }.maybe >>
+        spaced("STATUS") >> spaced { status } >>
+        spaced("DESCRIPTION") >> spaced { text } >>
+        spaced { refer_part }.maybe >>
+        spaced("SYNTAX") >> syntax |
+        syntax
+    end
+
+    rule(:refer_part) do
+      spaced("REFERENCE") >> text
+    end
+
+    rule(:choice_clause) do
+      # Ignoring choice syntax
+      spaced { str("CHOICE").as(:type) } >> curly(match("[^\}]").repeat)
+    end
+
+    rule(:syntax) do
+      object_syntax | spaced("BITS").as(:type) >> curly(named_bits)
+    end
+
+    rule(:display_part) do
+      spaced("DISPLAY-HINT") >> text
+    end
+
+    rule(:named_bits) do
+      with_separator(named_bit, ",")
+    end
+
+    rule(:named_bit) do
+      spaced { lowercase_identifier } >> bracketed(number)
+    end
+
+    rule(:object_syntax) do
+      conceptual_table |
+        entry_type |
+        simple_syntax |
+        application_syntax |
+        type_tag >> simple_syntax |
+        row.as(:value)
+    end
+
+    rule(:simple_syntax) do
+      spaced { str("INTEGER").as(:type) } >> (integer_subtype | enum_spec).maybe |
+        spaced { str("Integer32").as(:type) >> space } >> integer_subtype.maybe |
+        spaced { str("OCTET STRING").as(:type) } >> octetstring_subtype.maybe |
+        spaced { str("OBJECT IDENTIFIER").as(:type) } >> any_subtype |
+        spaced { uppercase_identifier.as(:type) } >> (integer_subtype | enum_spec | octetstring_subtype)
+    end
+
+    rule(:application_syntax) do
+      spaced { str("IpAddress").as(:type) >> space } >> any_subtype |
+        spaced { str("NetworkAddress").as(:type) >> space } >> any_subtype |
+        spaced { str("Counter32").as(:type) >> space } >> integer_subtype.maybe |
+        spaced { str("Gauge32").as(:type) >> space } >> integer_subtype.maybe |
+        spaced { str("Unsigned32").as(:type) >> space } >> integer_subtype.maybe |
+        spaced { str("TimeTicks").as(:type) >> space } >> any_subtype |
+        spaced { str("Opaque").as(:type) >> space } >> octetstring_subtype.maybe |
+        spaced { str("Counter64").as(:type) >> space } >> integer_subtype.maybe
+    end
+
+    rule(:conceptual_table) do
+      spaced { str("SEQUENCE OF").as(:type) } >> row.as(:value)
+    end
+
+    rule(:entry_type) do
+      spaced { str("SEQUENCE").as(:type) } >> curly(sequence_items)
+    end
+
+    rule(:type_tag) do
+      spaced { square_bracketed(spaced("APPLICATION") >> number.as(:application_type)) } >> spaced("IMPLICIT") |
+        spaced { square_bracketed(spaced("UNIVERSAL") >> number.as(:universal_type)) } >> spaced("IMPLICIT")
+    end
+
+    rule(:sequence_items) do
+      with_separator(sequence_item, ",")
+    end
+
+    rule(:sequence_item) do
+      spaced { lowercase_identifier } >> spaced { sequence_syntax }
+    end
+
+    rule(:sequence_syntax) do
+      str("BITS") |
+        sequence_object_syntax |
+        spaced { uppercase_identifier } >> any_subtype
+    end
+
+    rule(:sequence_object_syntax) do
+      sequence_simple_syntax | sequence_application_syntax
+    end
+
+    rule(:sequence_simple_syntax) do
+      spaced("INTEGER") >> any_subtype |
+        spaced("Integer32") >> any_subtype |
+        spaced("OCTET STRING") >> any_subtype |
+        spaced("OBJECT IDENTIFIER") >> any_subtype
+    end
+
+    rule(:sequence_application_syntax) do
+      spaced { str("IpAddress") >> space } >> any_subtype |
+        spaced { str("COUNTER32") } >> any_subtype |
+        spaced { str("Gauge32") >> space } >> any_subtype |
+        spaced { str("Unsigned32") >> space } >> any_subtype |
+        spaced { str("TimeTicks") >> space } >> any_subtype |
+        str("Opaque") |
+        spaced { str("Counter64") >> space } >> any_subtype
+    end
+
+    rule(:row) { uppercase_identifier }
+
+    rule(:integer_subtype) { bracketed(ranges) }
+
+    rule(:octetstring_subtype) do
+      bracketed(spaced("SIZE") >> bracketed(ranges))
+    end
+
+    rule(:any_subtype) do
+      (integer_subtype | octetstring_subtype | enum_spec).maybe
+    end
+
+    rule(:enum_spec) { curly(enum_items) }
+
+    rule(:enum_items) do
+      with_separator(enum_item.as(:enum), ",")
+    end
+
+    rule(:enum_item) do
+      fuzzy_lowercase_identifier.as(:name) >> space.repeat >> bracketed(number.as(:value))
+    end
+
+    rule(:ranges) do
+      with_separator(range.as(:range), "|")
+    end
+
+    rule(:range) do
+      value.as(:min) >> space.repeat >> (str("..") >> space.repeat >> value.as(:max)).maybe
+    end
+
+    rule(:value) do
+      number | hexstring | binstring
+    end
+
+    rule(:status) { lowercase_identifier }
+
+    rule(:uppercase_identifier) do
+      match("[A-Z]") >> match("[A-Za-z0-9\-]").repeat
+    end
+
+    rule(:lowercase_identifier) do
+      match("[a-z]") >> match("[A-Za-z0-9\-]").repeat
+    end
+
+    rule(:type_smi_and_sppi) do
+      str("IpAddress") | str("TimeTicks") | str("Opaque") | str("Integer32") | str("Unsigned32")
+    end
+
+    rule(:type_smi_only) do
+      str("Counter") | str("Gauge32") | str("Counter64")
+    end
+
+    rule(:colon_colon_part) { spaced("::=") }
+
+    rule(:space_in_line) { match('[ \t]').repeat(1) }
+    rule(:cr) { match("\n") }
+    rule(:space) do
+      # this rule match all not important text
+      (match('[ \t\r\n]') | comment_line).repeat(1)
+    end
+
+    rule(:comment_line) do
+      (match('\-\-') >> match('[^\n]').repeat >> match('\n'))
+    end
+
+    rule(:space?) { space.maybe }
+    rule(:digit) { match["0-9"] }
+    rule(:hexchar) { match("[0-9a-fA-F]") }
+    rule(:empty) { str("") }
+    rule(:number) do
+      (
+        str("-").maybe >> (
+          str("0") | (match("[1-9]") >> digit.repeat)
+        ) >> (
+          str(".") >> digit.repeat(1)
+        ).maybe >> (
+          match("[eE]") >> (str("+") | str("-")).maybe >> digit.repeat(1)
+        ).maybe
+      ).repeat(1)
+    end
+
+    rule(:hexstring) do
+      str("'") >> hexchar.repeat >> str("'") >> match("[hH]")
+    end
+
+    rule(:binstring) do
+      str("'") >> match["0-1"].repeat >> str("'")
+    end
+
+    rule(:text) do
+      str('"') >> (
+        str('\\') >> any | str('"').absent? >> any
+      ).repeat >> str('"')
+    end
+  end
+end

data/lib/netsnmp/oid.rb

@@ -10,16 +10,10 @@ module NETSNMP
 
     module_function
 
-    def build(o)
-      case o
-      when Array
-        o.join(".")
-      when OIDREGEX
-        o = o[1..-1] if o.start_with?(".")
-        o
-      # TODO: MIB to OID
-      else raise Error, "can't convert #{o} to OID"
-      end
+    def build(id)
+      oid = MIB.oid(id)
+      oid = oid[1..-1] if oid.start_with?(".")
+      oid
     end
 
     def to_asn(oid)

data/lib/netsnmp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module NETSNMP
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/sig/mib.rbs

@@ -0,0 +1,18 @@
+module NETSNMP
+  module MIB
+    MIBDIRS: Array[String]
+    PARSER: Parser
+
+    @parser_mutex: Mutex
+    @modules_loaded: Array[String]
+    @object_identifiers: Hash[String, String]
+
+    def self?.oid: (String identifier) -> String?
+                 | (Array[_ToS] identifier) -> String?
+
+    def self?.load: (String mod) -> void
+
+    def self?.load_imports: (?Hash[Symbol, untyped] data) -> Hash[String, Array[String]]?
+    def self?.load_defaults: () -> void
+  end
+end

data/sig/mib/parser.rbs

@@ -0,0 +1,7 @@
+module NETSNMP
+  module MIB
+    class Parser
+
+    end
+  end
+end

data/sig/oid.rbs

@@ -1,5 +1,5 @@
 module NETSNMP
-  type oid = String | Array[Integer]
+  type oid = String | Array[_ToS]
 
   type oid_type = Integer | :ipaddress | :counter32 | :gauge | :timetick | :opaque | :nsap | :counter64 | :uinteger
 

data/spec/client_spec.rb

@@ -22,7 +22,7 @@ RSpec.describe NETSNMP::Client do
       let(:get_oid) { "1.3.6.1.2.1.1.5.0" }
       let(:next_oid) { "1.3.6.1.2.1.1.6.0" }
       let(:walk_oid) { "1.3.6.1.2.1.1" }
-      let(:set_oid) { "1.3.6.1.2.1.1.3.0" } # sysUpTimeInstance
+      let(:set_oid) { "sysUpTime.0" } # sysUpTimeInstance
       let(:get_result) { "DEVICE-192.168.1.1" }
       let(:next_result) { "The Cloud" }
       let(:walk_result) do
@@ -48,10 +48,10 @@ RSpec.describe NETSNMP::Client do
           community: "public"
         }
       end
-      let(:get_oid) { "1.3.6.1.2.1.1.5.0" }
+      let(:get_oid) { "sysName.0" }
       let(:next_oid) { "1.3.6.1.2.1.1.6.0" }
-      let(:walk_oid) { "1.3.6.1.2.1.1" }
-      let(:set_oid) { "1.3.6.1.2.1.1.3.0" }
+      let(:walk_oid) { "system" }
+      let(:set_oid) { "sysUpTime.0" }
       let(:get_result) { "DEVICE-192.168.1.1" }
       let(:next_result) { "The Cloud" }
       let(:walk_result) do
@@ -78,9 +78,9 @@ RSpec.describe NETSNMP::Client do
         context: "a172334d7d97871b72241397f713fa12"
       }
     end
-    let(:get_oid) { "1.3.6.1.2.1.1.5.0" }
+    let(:get_oid) { "sysName.0" }
     let(:next_oid) { "1.3.6.1.2.1.1.6.0" }
-    let(:set_oid) { "1.3.6.1.2.1.1.3.0" } # sysUpTimeInstance
+    let(:set_oid) { "sysUpTime.0" } # sysUpTimeInstance
     let(:walk_oid) { "1.3.6.1.2.1.1.9.1.3" }
     let(:get_result) { "tt" }
     let(:next_result) { "KK12" }

data/spec/handlers/celluloid_spec.rb

@@ -4,7 +4,7 @@ require "celluloid/io"
 require_relative "../support/request_examples"
 require_relative "../support/celluloid"
 
-RSpec.describe "with cellulloid", type: :celluloid do
+RSpec.describe "with cellulloid", type: :celluloid, if: RUBY_ENGINE == "truffleruby" do
   include CelluloidHelpers
   let(:user_options) do
     { username: "authprivmd5des", auth_password: "maplesyrup",

data/spec/mib_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+RSpec.describe NETSNMP::MIB do
+  describe ".oid" do
+    it { expect(described_class.oid("1.2.3.4")).to eq("1.2.3.4") }
+    it { expect(described_class.oid("ifTable")).to eq("1.3.6.1.2.1.2.2") }
+    it { expect(described_class.oid("sysDescr.0")).to eq("1.3.6.1.2.1.1.1.0") }
+    it { expect(described_class.oid("ifTable.1.23")).to eq("1.3.6.1.2.1.2.2.1.23") }
+    it { expect(described_class.oid("IF-MIB::ifTable.1.23")).to eq("1.3.6.1.2.1.2.2.1.23") }
+    it { expect(described_class.oid("IFMIB::ifTable.1.23")).to be_nil }
+    it { expect(described_class.oid("IF-MIB::")).to be_nil }
+  end
+end

data/spec/spec_helper.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+GC.auto_compact = true if GC.respond_to?(:auto_compact=)
+
 if ENV.key?("CI")
   require "simplecov"
   SimpleCov.command_name "#{RUBY_ENGINE}-#{RUBY_VERSION}"

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: netsnmp
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Tiago Cardoso
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-12-18 00:00:00.000000000 Z
-dependencies: []
+date: 2021-01-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: |2
       Wraps the net-snmp core usage into idiomatic ruby.
       It is designed to support as many environments and concurrency frameworks as possible.
@@ -28,6 +42,8 @@ files:
 - lib/netsnmp/encryption/none.rb
 - lib/netsnmp/errors.rb
 - lib/netsnmp/message.rb
+- lib/netsnmp/mib.rb
+- lib/netsnmp/mib/parser.rb
 - lib/netsnmp/oid.rb
 - lib/netsnmp/pdu.rb
 - lib/netsnmp/scoped_pdu.rb
@@ -39,6 +55,8 @@ files:
 - lib/netsnmp/version.rb
 - sig/client.rbs
 - sig/message.rbs
+- sig/mib.rbs
+- sig/mib/parser.rbs
 - sig/netsnmp.rbs
 - sig/oid.rbs
 - sig/openssl.rbs
@@ -51,6 +69,7 @@ files:
 - sig/varbind.rbs
 - spec/client_spec.rb
 - spec/handlers/celluloid_spec.rb
+- spec/mib_spec.rb
 - spec/oid_spec.rb
 - spec/pdu_spec.rb
 - spec/security_parameters_spec.rb
@@ -91,6 +110,7 @@ test_files:
 - spec/spec_helper.rb
 - spec/session_spec.rb
 - spec/client_spec.rb
+- spec/mib_spec.rb
 - spec/oid_spec.rb
 - spec/varbind_spec.rb
 - spec/support/request_examples.rb