Free bayer diagnostics software for linux

mod_diagnostics is a debugging and diagnostic tool for application developers - particularly filter modules.

mod_diagnostics.c can be inserted anywhere in the Apache filter chain, and logs traffic (buckets and brigades) passing through.

It is a purely passive watcher, and will never touch the traffic passing through.

Examples

Probably the best way to explain mod_diagnistics is by example.

Strange delays in some browsers

In an update to mod_xml, a new bug was introduced. It was not immediately obvious, but in some browsers the request would hang and then timeout. The effect was only observed when using the XSLT output filter with Xalan-C, and only happened with HTTP/1.1 browser, not with HTTP/1.0. Furthermore, hitting "cancel" before the timeout in an HTTP/1.1 browser would cause the page to display!
Inserting mod_diagnostics before and after the offending filter, the bug was immediately obvious. The module was simply failing to pass an EOS bucket down the chain. A trivial fix!

Obscure bug in a third-party library

A user of mod_proxy_html reported serious performance problems when parsing an 8Mb HTML file. He had profiled the problem, and found the entire processing time was in the final call to htmlParseChunk in libxml2.

I investigated this by inserting mod_diagnostics before and after mod_proxy_html, and running it with the largest HTML document I had available (the MySQL manual, about 2.6Mb). I was able to confirm that nothing was passed down the chain until the final call, so not only was it slow, but it had also broken Apache pipelining.

To refine the diagnosis, I added a flush in each call to the filter in mod_proxy_html. Now mod_diagnostics showed a small amount of data (under 1Kb) coming through in the first call to the filter, but nothing else until the end. Further investigation showed that the data stopped coming when the first HTML comment was encountered in the source.

At this point I ran it under gdb, looking for the comment handling. I found that it was failing to find the end of the comment. The problem was resolved only in the last call to htmlParseChunk, which didnt go through the buggy code. I disabled the buggy code, and found it was now working correctly, with approximately the same amount of input and output data in each call to the mod_proxy_html filter - so pipelining was now fixed. My correspondent reported total processing Time for his 8Mb file reduced from 30 minutes to 9 seconds (on five-year-old hardware).

The bug was reported to the libxml team, who have now fixed it.

Iterator::IO is a Perl module with filesystem and stream iterators.

SYNOPSIS

use Iterator::IO;

# Return the names of files in a directory (except . and ..)
$iter = idir_listing ($path);

# Return all the files in a directory tree, one at a time.
# Like File::Find, in slow motion.
$iter = idir_walk ($path);

# Return the lines of a file, one at a time.
$iter = ifile ($filename, %options);

# Return the lines of a file, in reverse order
$iter = ifile_reverse ($filename, %options);

This module provides filesystem and stream iterator functions. See the Iterator module for more information about how to use iterators.

FUNCTIONS

idir_listing

$iter = idir_listing ($path);

Iterator that returns the names of the files in the $path directory. If $path is omitted, defaults to the current directory. Does not return the . and .. files (under unix).

Requires IO::Dir and Cwd.

Example:

To return only certain files, combine this with an igrep:

$iter = igrep {-s && -M < 1} idir "/some/path";

(Returns non-empty files modified less than a day ago). (igrep) is defined in the Iterator::Util module).

idir_walk

$iter = idir_walk ($path);

Returns the files in a directory tree, one by one. Its sort of like File::Find in slow motion.

Requires IO::Dir and Cwd.

ifile

$iter = ifile ($filename, %options);

Opens a file, generates an iterator to return the lines of the file.
%options is a reference to a hash of options. Currently, two options are supported:

chomp

chomp => boolean indicates whether lines should be chomped before being returned by the iterator. The default is true.

$/

$/ => value specifies what string to use as the record separator. If not specified, the current value of $/ is used.

"rs" or "input_record_separator" may be used as option names instead of "$/", if you find that to be more readable. See the English module.

Option names are case-insensitive.

ifile requires IO::File.
ifile_reverse

$iter = ifile_reverse ($filename, %options);

Exactly the same as "ifile", but reads the lines of the file backwards.
The input_record_separator option values undef (slurp whole file) and scalar references (fixed-length records) are not currently supported.

INTERFACE CHANGE

In version 0.01 of Iterator::IO, the "ifile" and ifile_reverse functions accepted their options in a different manner. This has now changed to operate via a hash reference of options. The old way will still work, but is deprecated and will be removed in a future release.

EXPORTS

This module exports all function names to the callers namespace by default.

DIAGNOSTICS

Iterator::IO uses Exception::Class objects for throwing exceptions. If youre not familiar with Exception::Class, dont worry; these exception objects work just like $@ does with die and croak, but they are easier to work with if you are trapping errors.

See the Iterator module documentation for more information on how to trap and handle these exception objects.

Parameter Errors

Class: Iterator::X::Parameter_Error

You called an Iterator::IO function with one or more bad parameters. Since this is almost certainly a coding error, there is probably not much use in handling this sort of exception.

As a string, this exception provides a human-readable message about what the problem was.

Exhausted Iterators

Class: Iterator::X::Exhausted

You called value on an iterator that is exhausted; that is, there are no more values in the sequence to return.

As a string, this exception is "Iterator is exhausted."

I/O Errors

Class: Iterator::X::IO_Error

This exception is thrown when any sort of I/O error occurs; this only happens with the filesystem iterators.

This exception has one method, os_error, which returns the original $! that was trapped by the Iterator object.

As a string, this exception provides some human-readable information along with $!.

Internal Errors

Class: Iterator::X::Internal_Error

Something happened that I thought couldnt possibly happen. I would appreciate it if you could send me an email message detailing the circumstances of the error.

BixData is a system monitoring tool. BixData monitors services (HTTP, ping, POP3, SMTP), performance, and processes. You can create critical notifications and get email alerts for HTTP, ping, CPU, memory, and even SMART diagnostics.
A graphical console for Linux and Windows supports real-time dynamic graphs. The runtime clients and server component are lightweight and easy to set up, and run on Linux and Windows.
Main features:
- Supports Linux and Windows
- Server monitoring, Email Notifications
- HTTP, ping, POP3, SMTP
- CPU Load
- Memory Usage
- Disk Performance
- SMART Hard Disk Drive Information
- Network Statistics
- Process Statistics
- Windows Performance Counters
- Real-Time Graphs
- System Information
- Configure Startup Services
- WMI
- Low Bandwith Usage
- Secure
Enhancements:
- This release adds MySQL database monitoring.
- It also supports adding your own custom scripts for monitoring and creating new reporting templates.
- There are minor desktop UI improvements.
- Important fixes and enhancements are included to improve stability in Agent and Server on Linux, Mac OS X, FreeBSD, and Windows.

The CAN Abstraction Layer (CANAL) provides a single interface for programs to use different CAN drivers.
It consists of a CANAL daemon that handles client and driver communication, a canalLogger that logs messages in a window, and a simple diagnostic application. C++ clases and DLL/DL interfaces are provided.
Enhancements:
- The configuration readings for CanalWorks were upgraded.
- A GUID ordering problem in canald was fixed.
- A problem with clear message list switch in CanalWorks was fixed.
- A problem in which Linux version Level I received a thread with an invalid count returned for DataAvailable was fixed.

Graphics3D is a free, Open Source C++ library for game developers, researchers, and students. Graphics3D project is a base of robust and high performance code common to most 3D projects.
It is not a standalone graphics or game engine--it is the set of pieces you need to jumpstart your own engine or graphics project. The library has two parts: G3D for pure math, and GLG3D for interacting with hardware acceleration via OpenGL.
You can use G3D without GLG3D if you want to use another 3D API (like DirectX) or dont like the OpenGL abstraction.
G3D does not contain scene graph or GUI routines. Because of this, there is a lot of flexibility to how you structure your programs. The tradeoff is that you have to know more about 3D programming. G3D is intended for users who are already familiar with C++ and DirectX or OpenGL.
G3D does not draw widgets by itself. Several good G3D-compatible GUI libraries exist and we recommend using one with G3D if your project has extensive UI needs.
Enhancements:
- Rendering is now approximately 20% faster for applications using the high-level ArticulatedModel and IFSModel objects.
- A new Half-life-style interactive text console and World of Warcraft-style camera controller enable more sophisticated debugging and interaction.
- Other new features include querying texture dimensions from GLSL shaders, support for Mesa3D software rendering, and high-quality Bayer-to-RGB conversion for video frames.

This is a program for enumerating ipx nodes on a network. It works by sending an ipx ping packet to all nodes on a network. In addition to printing the ipx network and node address it is able to: print the hexdump of the packet (-h option), try to identify the ipx stack on the node (-i option - please note that this is unreliable at best), and parse the diagnostic response (-p option) giving the ipx version, the spx diagnostic socket, a list of installed components, a list of interfaces in case of routers etc. By default the program uses all networks in /proc/net/ipx_route. If you want to limit the query to a single network use the -n option (like -n 12abc, -n 0 is always the local network).

These are the available options:
Avaliable options:
--help: help
-h : hexdump of the ping response
-i : try to identify the node (unreliable at best), you will get a
hexdump of the response if identification fails
-p : parse diagnostic message
-a : equivalent to -h -p -i
-n NET: ping only single net
-t sec: how much to wait for responses in seconds (default: 2)

Test::Struct is a Perl extension for testing for structural equivelence.

SYNOPSIS

use Test::Struct;

deep_eq($hairy_struct,$expected,Hairy structural test);
is($x,$y); # and everything else Test::More has to offer!

Test::Struct is used for doing deep structural comparisons of two objects. The module contains only one subrotuine which is intended to be used as a mix-in with other more generic Test::Builder derived modules like Test::More or Test::Simple. The code normally uses Scalar::Util for inspecting the data, but it will also use additional fine tuned comparison tools from Data::Dump::Streamer if they are available.
deep_eq($got,$expected,$name)

Does a deep level comparison of two objects. It traverses the two structures in parallel checking as many attributes as it can for differences. If the objects differ it will output a diagnostic message containing a list of the differences it encountered before it finished the comparison. Some types of mismatch prevent further comparison so the list may not be exhaustive.

The intention of this routine is that it will pass the test only if $got is functionally identical to $expected. However, at current time there are some data types it does not handle properly, such as CODE refs.