I first became mildly interested in Tcl in 1993 when I was working with Digital Equipment Corporation. I was talking with Glenn Trewitt, a brilliant engineer with Digital's Western Research Laboratory, about an IP path tracing/diagnostic tool I was working on, and Glenn mentioned how he had just built an SNMP interface onto Tcl. At the time, the only thing I knew about Tcl was that it was an interpretive scripting language. I had spent the last three years programming in C and the previous eight years programming in assembly language, and the last thing I wanted to do was move to a scripting language, so I listened politely as Glenn described the interface he had built. Still, I had a great deal of respect for Glenn, great enough that I bought John Ousterhout's book Tcl and the Tk Toolkit book when it came out, but I wasn't yet motivated enough to take Tcl seriously.
At the end of 1993, I left Digtial to join LightStream Corporation. LightStream was building an ATM/Ethernet switch and I was given the opportunity to build a large bulk of the network management software. The test engineers were using Tcl/Tk to build their test platform. I was impressed with how quickly they were able to build their user interfaces using Tcl/Tk, but in my own mind, that just meant Tcl/Tk was good for building test tools. I still wasn't taking it seriously for network management. By the end of 1994, we were purchased by Cisco. As a newly appointed Cisco employee, I visited the headquarters in San Jose and had a code walk-through of the CiscoView application-written completely in Tcl/Tk. For the first time, I began to see the power of building network management applications with Tcl. A few months later, I left Cisco to join 3Com. One of the engineers in my group had discovered Scotty and wanted to develop on it (Scotty, among other things, provides an SNMP extension for Tcl). I was building a network monitoring/diagnostic tool for 3Com's LANplex switches and needed a tool to simulate the vast number of complex FDDI and system traps that the LANplex can generate, so I had this engineer build a trap simulation tool using Scotty. The tool was built quickly and was extremely powerful in how it simulated device traps. I was now more serious about Tcl.
The application I was building collected quite a bit of information from each interface on a switch and then ran the information through a series of expressions to determine how the switch was operating. The application supported up to several hundred switches at a time, and each switch could have 24-80 interfaces for which information would have to be gathered. Assuming about ten expressions per interface and a collection interval as short as 30 seconds, the application had a lot of expressions to evaluate every minute.
As an experiment, we replaced the C++ code that was performing expression evaluation with Tcl code. Performance quickly became a problem. It was just too many expressions for Tcl to keep up with. In my mind, this proved that Tcl was geared only toward a subset of tools and network management applications, and was not applicable for the large-scale network monitoring application I was working on. Besides, I was now developing in C++ and did not want to move to a scripting language.
For the next year and a half I ignored Tcl. Then I noticed Jerry Puoplo, who at the time was an engineering manager for Transcend at 3Com, building useful network management tools using Tcl with the TickleMan extensions. Mind you, this was a manager building tools at a much faster pace than any of the engineers in his group. And they were useful tools-like collecting network inventory information and performing a network discovery. It finally hit me. While Tcl may not be appropriate for large-scale applications that are computationally-intensive, it is perfectly suited for a large number of network management tools-especially the type typically built by network managers and network consultants.
My goal for this book is to help network managers and network consultants get to the point that it took me four years to get to-that very powerful and useful network management tools can be written quickly and easily with Tcl/Tk.
In the preface to their book, How to Manage Your network Using SNMP--The Network management Practicum, Marshall Rose and Keith McCloghrie categorized their book as a preparedness book. The topic of this book has much in common with Marshall and Keith's book: that this too is a preparedness book. It's a book to prepare you to create and maintain custom-built network management utilities.
Anyone who has worked in network operations knows that some of the best network management tools are custom-built tools developed by network managers or network management consultants. I have seen many NOCs (Network Operations Centers) and it's easy to see which ones have their heads above water and which are drowning. The ones swimming along merrily have a defined strategy for how to manage their network via management tools. Over time, they have developed a number of useful custom tools that they have integrated with their vendor-based tools.
Unfortunately, many network managers do not have a strategy for developing and evolving their own network management tools. Some may feel they don't have the skill set or largeness of scope to even think of this as they continue to fight fires without adequate tools. Others may be blindly using PERL scripts with the HP OpenView SNMP APIs without knowing of any other alternative.
You may also have the problem where your typical day at work is putting out fires and hence you never have time during your workday to be proactive. This for years delayed my progress implementing custom tools. However, all that changed when I was able to develop custom tools at home on my PC and later run the same tools at work on my UNIX management system.
Building custom management tools will empower network managers, network consultants and network support engineers. They have a wealth of useful utilities inside of them that would make them more productive if they knew how to use Tcl with SNMP extensions.
Recently, I was visiting a NOC in the midst of a major network problem. I watched the pain on the faces of the vendor's network support engineers as they tried to obtain data on device operations using a MIB browser. If those network engineers knew Tcl with SNMP, I bet one of the first things they would do is spend a few days building simple Tcl-based diagnostic tools.
This book is for them and others like them. The various sample applications it describes exist to prepare network managers, network consultants and network support engineers to build custom management utilities. Creating custom tools is both satisfying and effective in helping to manage a network.
Throughout this book we will use a Courier font for both source code listings and for commands typed at a console window. Furthermore, results for commands typed at a console will be preceded by a Þ. For example:
set x 100 Þ 100
The Tcl command in this example, set x 100, appears in the Courier font. The result for this example, 100, appears on the following line. The Þ symbol in the above example is not part of the return value. In describing Tcl command syntax, the notation, ? arg ?, denotes an optional argument. The syntax, ? arg ... arg?, denotes one or more optional arguments.
The chapters of this book are divided into three parts. The first part describes the motivation for using Tcl to build network management tools. Chapter 1 provides a brief introduction to Tcl and describes how it can be used to help manage a network. In Chapter 2 we expand on this theme and present the sample tools that we will be building later in the book and our motivation for originally building them (most of these tools were built before we ever conceived of this book).
In Part II, we start to lay a foundation for using Tcl to build network management tools. Chapters 3 and 4 provide both an introduction to Tcl and some basic Tcl procedures that will be used later with our sample tools. Chapter 5 examines two SNMP extension packages to Tcl, TickleMan, a commercial product available from SNMP Research, and Scotty, available both commercially and in some form as a freeware product. The freeware version of Scotty can be obtained over the Internet. In Chapter 6 we build a fairly robust SNMP polling loop and show how it can be used to periodically calculate several network statistics. In Chapter 7 we start to explore Tk, and use a step-by-step approach to build a sample user interface that can serve as a template for building network management application user interfaces. In Chapter 8 we build a simple table widget that will later be used by several of our sample tools. We also further explore Tk canvases, showing how to use them to draw an IP path. We end the chapter by exploring Itcl Mega-Widget
Use Tcl/Tk to build the custom network management tools you need.
Often, there's no substitute for a custom network management tool-but you can't afford to spend months building one. There's a quick, easy solution: Tcl/Tk scripts. Learn to leverage Tcl/Tk's power and efficiency-from experts who've built successful network management products for Cisco, Digital and 3Com.
Discover why Tcl/Tk tools are perfect for troubleshooting, device monitoring, inventory, configuration, and many other network management applications. Then build five real-world applications to use right away, learning concepts and routines you'll reuse constantly:
Learn proven techniques for Web-enabling your network management applications-and for building tools that are extensible and easy to modify. Carefully annotated code and extensive screen captures show exactly what to expect. An accompanying Web site includes downloadable source code, new tips and insights, and much more.
With Building Network Management Tools with Tcl/Tk, you can deploy the tools you really need-when you need them.
"About this title" may belong to another edition of this title.
Book Description Prentice Hall PTR. Hardcover. Book Condition: New. 0130807273 New Condition. Bookseller Inventory # NEW6.0044884
Book Description Prentice Hall PTR, 1998. Hardcover. Book Condition: New. 1st. Bookseller Inventory # DADAX0130807273
Book Description Prentice Hall PTR, 1998. Hardcover. Book Condition: New. book. Bookseller Inventory # 0130807273
Book Description Prentice Hall PTR, 1998. Hardcover. Book Condition: New. New item. Bookseller Inventory # QX-005-37-9636109
Book Description Prentice-Hall. Book Condition: New. pp. 429. Bookseller Inventory # 4688025
Book Description Book Condition: Brand New. Book Condition: Brand New. Bookseller Inventory # 97801308072741.0