Subject: RE: Fwd: Regarding Agentx

From: "Ayers, Mike" <[email-masked]>
Date: Wed, 23 Aug 2000 12:27:36 -0500

> From: Daris A Nevil [mailto:[email-masked]]

> 
> Thanks for the feedback.  Since we are running in an embedded system
> we never want to have our subagent disconnected.  And it should never
> disconnect anyway, since we are using Unix domain sockets.  If we were
> using the TCP socket protocol then I could see the importance of the
> connection management code.

	I was mostly concerned about the possibility that the patch you
posted would start making rounds, leaving some folks unaware that they were
now using a noncompliant master agent.

> We are currently experienting with the timeout mechanism, but its not
> too cut-and-dry since we have variable response times from our managed
> cards depending on the data (sent to our subagent).

	Suggestion:  use a limit size of 1500 bytes, sufficient to pass the
largest ethernet frame, and calculate the timeout as twice the time to move
1500 bytes (you may wish to adjust for AgentX overhead in search ranges,
etc.) plus max computational time.  Now double it.  That should give you a
workable timeout value.  If the computational times vary wildly (often a
problem in realtime systems), you may want to consider using MIB semaphoring
or some such mechanism, since SNMP tends to tacitly assume trivial
computational times for instance values.

/|/|ike

---

From: "Ayers, Mike" <[email-masked]>
Date: Wed, 30 Aug 2000 12:31:24 -0500

Since Matt has stepped in (he is the authority after all), there is
little more for me to say on the subject.  However, I will repost one of his
responses to the UCD-SNMP group, as well as Dave Shield's reply to the same
query (both reposted without headers 'cause I'm stuck with Outlook).
Hopefully, this (and what has been discussed here so far) will give you
everything you need.

/|/|ike

=======8<------From Matt White 16Aug00---------------
Doesn't look like there's been a release of the CMU AgentX code since I
left CMU (and stopped developing it) a year ago.  My informal discussions
with people at CMU indicate that they do not have the resources to
continue development on this code at this time.  That may change in the
future, but these things are hard to judge.

So, if the CMU code as it stands right now does what you want, you're in
good shape, otherwise you should go with the UCD code.  Or you can use
both.  The last I checked, there was interoperability between the two
versions.

Weaknesses in the CMU code:
*  The CMU master agent does not support SNMPv3 and won't for some time,
   if ever.
*  The CMU subagent library and master agent don't support agent
   capabilities or notifications.
*  There is no subagent MIB compiler for the CMU subagent.

It's been a while since I've looked at this code, but I think those are
the biggies.

If it were me, I would probably use the UC Davis code.

Matt White
Ericsson IP Infrastructure

On Thu, 10 Aug 2000, Qing Zhang wrote:

> 
> Good Morning,
> 
> I am currently evaluating public domain AgentX implementation.
> 
> I got CMU AgentX compiled and I can run snmpd and the test program.
> Seems the basic features are working.
> 
> I planned to try the UCD AgentX implementation.
> 
> Before I dive into the UCD AgentX, I would like to get some feedbacks
> from people who have used it. More specifically, I would like to know
> the followings regarding both CMU and UCD AgentX:
> 
> - Features missed;
> - Major bugs;
> - Weakness;
> - etc.
> 
> Any comments are extremely welcome. Thanks in advance.
> 
> --
> Senior Software Designer, Motorola Canada Ltd.
> [email-masked], Tel: (604) 241-6422
> 
> 
> 
=======8<--------------------------------------------

=======8<------From Dave Shield 11Aug00--------------
> I am currently evaluating public domain AgentX implementation.
> 
> I got CMU AgentX compiled and I can run snmpd and the test program.
> Seems the basic features are working.
> 
> I planned to try the UCD AgentX implementation.
> 
> Before I dive into the UCD AgentX, I would like to get some feedbacks
> from people who have used it.

OK - I'll have a go at responding.
Note that it's a little while since I last looked at the
CMU AgentX work, so some of my comments may be out of date.

The CMU and UCD teams have been approaching this from
somewhat different directions.

  My impression of the CMU package is that it's starting from
the client side, and has developed a library for instrumenting
an external application.   The CMU master agent is deliberately
an "empty shell" - that simply delegates requests down to subagent
(i.e instrumented applications).   These applications are therefore
reasonably "AgentX-aware".

  The UCD approach has been the reverse - starting from the agent
and turning an SNMP-only agent into a dual-role system.  The support
for an instrumented application is effectively a very stripped down
version of this.   This has an number of implications, not least that
applications are much less "AgentX-aware"
  (The agent-handling code is fully contained within library routines,
and the instrumentation API is protocol-independent, since it's the
same as is used for the main UCD agent).

  Other comparisons that spring to mind:

  -  the CMU code is probably lighter than the UCD equivalent,
since this is designed for this specific requirement, rather than
being an incremental development of an existing SNMP library.

  -  the UCD master agent is "fuller" than the CMU equivalent.
Particularly with regard to such things as access-control, SNMP
statistics, trap notifications, etc - all of which can most sensibly
be handled by the master agent itself.

  -  the CMU code is somewhat more stable than the UCD implemention.
The current UCD version (4.1.2) was the first public release of the
AgentX code, and is very much "experimental".  This support has
developed a fair deal since then, and the current development version
is notably more reliable and functional than the 4.1.2 code.

  -  the UCD code is rather more up-to-date than the CMU offering.
The last comments on the CMU web page are from 1998 (though the
latest code appears to date from July 1999).    I haven't looked
at the 1.4 versions, but the 1.3 release was certainly built on
the previous version of the AgentX protocol.  The current versions
is subtly different in certain respects (which may lead to some
problems with interoperability).

  -  the UCD code is rather more complete that the CMU version.
Again, this is w.r.t the 1.3 CMU release, but that didn't implement
certain of the AgentX protocol operations.  This may have been addressed
with 1.4 - I haven't looked.   The UCD offering does attempt to handle
the full AgentX protocol (including index allocation, ping, etc).
Which isn't to claim there aren't any problems, but the basic support
is there.

  These aren't the only two options, of course.  I know that the Agent++
people have been working on AgentX support, and I believe the Advent
agent also includes this facility.  There may well be others.

  Anyway, I trust that these rambling have been both fair, and useful.

Dave
=======8<--------------------------------------------