Free nodes software for linux

PingNode will ping a list of network devices at a specified interval. PingNode will then create a record in a MySQL database for each ping indicating that the node was there or not there.

It will also send an email if the node is found to be down. The index.php page contains a list of monitored hosts with current status.

A detail page contains historical data for a given host.

ToDo:

Seperate table for hosts
Query data by date range
Dynamic host add/delete/modify
Custom Reports
disk space monitor
Process/Service monitor

Node Director project is a system management application for centralized user and host management in small to medium sized Unix / Linux / (Windows) system environments.
Main features:
- user management; templates and user classes make creation of users easy
- delegation of routine administration tasks
- data storage via LDAP - clients can directly bind to the LDAP database server
- flexible directory and name services - manages NIS, DNS, static DHCP entries, Samba users, LDAP ? LDAP transformations, file based databases like /etc/passwd, /etc/group, /etc/hosts, ...
- single account / password across multiple systems and applications
- software distribution
- service configuration (e.g. sendmail, bind, ntp, ...) via template mechanism
- customizable actions on events like e.g. account creation, password change, host configuration change, ... where actions include home directory creation, service restart, execution of arbitrary commands on target system and many many more
The Director is currently mainly deployed on Linux systems and therefore supports Linux best. Most Unix systems are not directly supported but the Director will work. There is some limitted functionality for Windows machines, too.
The Node Director requires an LDAP accessible database engine, such as the free OpenLDAP or the SUN / Netscape Directory Server. Virtually, any directory server that implements LDAP v2 or v3 and allows custom schema extensions should do, the development team uses OpenLDAP, and the Director has been successfully tested with the Sun Java System Directory Server 5.2.
The Director is in no means meant as a mere frontend for editing arbitrary data in LDAP accessible directory trees. It rather is a system management software storing its information via LDAP in RFC-compliant objects. The difference is that when you work with the Director you will never care about LDAP specific things like attributes, DNs, object classes, whatever (unless you want, of course). You will work with lists (e.g. of users) and forms (e.g. a single user account).
Anyway, the data is stored in an LDAP tree. While the Director comes with a number of means of updating name services like DNS, the system password/account database, Samba, etc. clients can directly bind via LDAP to the data store and access account / host records (e.g. via nss_ldap).

XML::Mini::Node contains nodes that are used as atomic containers for numerical and text data and act as leaves in the XML tree.

They have no name or children.

They always exist as children of XML::MiniElements. For example, < B >this text is bold< /B > Would be represented as a XML::MiniElement named B with a single child, a Node object which contains the string this text is bold.
a Node has

- a parent
- data (text OR numeric)

getValue

Returns the text or numeric value of this Node.

text [SETTO [SETTOALT]]

The text() method is used to get or set text data for this node. If SETTO is passed, the nodes content is set to the SETTO string.

If the optional SETTOALT is passed and SETTO is false, the nodes value is set to SETTOALT.

Returns this nodes text, if set or NULL

numeric [SETTO [SETTOALT]]

The numeric() method is used to get or set numerical data for this node.

If SETTO is passed, the nodes content is set to the SETTO string.

If the optional SETTOALT is passed and SETTO is NULL, the nodes value is set to SETTOALT.

Returns this nodes text, if set or NULL

toString [DEPTH]

Returns this nodes contents as a string. If the special DEPTH $XML::Mini::NoWhiteSpaces is passed, no whitespaces will be inserted.

Bio::NEXUS::Node is a Perl module that provides functions for manipulating nodes in trees.

SYNOPSIS

new Bio::NEXUS::Node;

METHODS

new

Title : new
Usage : $node = new Bio::NEXUS::Node();
Function: Creates a new Bio::NEXUS::Node object
Returns : Bio::NEXUS::Node object
Args : none

clone

Title : clone
Usage : my $newblock = $block->clone();
Function: clone a block object (shallow)
Returns : Block object
Args : none

get_seq

Title : get_seq
Usage : $sequence = $node->get_seq();
Function: Returns the nodes sequence
Returns : sequence (string)
Args : none

set_seq

Title : set_seq
Usage : $node->set_seq($sequence);
Function: Sets sequence of the node
Returns : none
Args : sequence (string)

set_parent_node

Title : set_parent_node
Usage : $node->set_parent_node($parent);
Function: Sets the parent node of the node
Returns : none
Args : parent node (Bio::NEXUS::Node object)

get_parent

Title : get_parent
Usage : $parent=$node->get_parent();
Function: Returns the parent node of the node
Returns : parent node (Bio::NEXUS::Node object) or undef if nonexistent
Args : none

set_length

Title : set_length
Usage : $node->set_length($length);
Function: Sets the nodes length (meaning the length of the branch leading to the node)
Returns : none
Args : length (number)

get_length

Title : length
Usage : $length=$node->get_length();
Function: Returns the nodes length
Returns : length (integer) or undef if nonexistent
Args : none

get_total_length

Title : get_total_length
Usage : $total_length = $node->get_total_length();
Function: Gets the total branch length of the node and that of all the children (???)
Returns : total branch length
Args : none

set_support_value

Title : set_support_value
Usage : $node->set_support_value($bootstrap);
Function: Sets the branch support value associated with this node
Returns : none
Args : bootstrap value (integer)

get_support_value

Title : get_support_value
Usage : $bootstrap=$node->get_support_value();
Function: Returns the branch support value associated with this node
Returns : bootstrap value (integer) or undef if nonexistent
Args : none

set_name

Title : set_name
Usage : $node->set_name($name);
Function: Sets the nodes name
Returns : none
Args : name (string/integer)

get_name

Title : get_name
Usage : $name = $node->get_name();
Function: Returns the nodes name
Returns : name (integer/string) or undef if nonexistent
Args : none

is_otu

Title : is_otu
Usage : $node->is_otu();
Function: Returns 1 if the node is an OTU or 0 if it is not (internal node)
Returns : 1 or 0
Args : none

add_child

Title : add_childTU
Usage : $node->add_child($node);
Function: Adds a child to an existing node
Returns : none
Args : child (Bio::NEXUS::Node object)

distance

Title : distance
Usage : $distance = $node1->distance($node2);
Function: Calculates tree distance from one node to another (?)
Returns : distance (floating-point number)
Args : node1, node2 (Bio::NEXUS::Node objects)

to_string

Title : to_string
Usage : my $string; $root->tree_string($string, 0)
Function: recursively builds Newick tree string from root to tips
Returns : none
Args : reference to string, boolean $remove_inode_names flag

set_children

Title : set_children
Usage : $node->set_children($children);
Function: Sets children
Returns : $node
Args : arrayref of children

get_children

Title : get_children
Usage : @children = @{ $node->get_children() };
Function: Retrieves list of children
Returns : array of children (Bio::NEXUS::Node objects)
Args : none

walk

Title : walk
Usage : @descendents = $node->walk();
Function: Walks through tree and compiles a "clade list"
(including $self and all inodes and otus descended from $self)
Returns : array of nodes
Args : generally, none, though walk() calls itself recurseively with
2 arguments: the node list so far, and a counting variable for inode-naming

get_otus

Title : get_otus
Usage : @listOTU = @{$node->get_otu()}; (?)
Function: Retrieves list of OTUs
Returns : reference to array of OTUs (Bio::NEXUS::Node objects)
Args : none

printall

Title : printall
Usage : $tree_as_string = $self->printall();
Function: Gets the node properties as a tabbed string for printing nicely
formatted trees (developed by Tom)
Returns : Formatted string
Args : Bio::NEXUS::Node object

find

Title : find
Usage : $node = $node->find($name);
Function: Finds the first occurrence of a node called name in the tree
Returns : Bio::NEXUS::Node object
Args : name (string)

prune

Name : prune
Usage : $node->prune($OTUlist);
Function: Removes everything from the tree except for OTUs specified in $OTUlist
Returns : none
Args : list of OTUs (string)

equals

Name : equals
Usage : $node->equals($another_node);
Function: compare if two nodes (and their subtrees) are equivalent
Returns : 1 if equal or 0 if not
Args : another Node object

get_siblings

Name : get_siblings
Usage : $node->get_siblings();
Function: get sibling nodes of this node
Returns : array ref of sibling nodes
Args : none

is_sibling

Name : is_sibling
Usage : $node1->is_sibling($node2);
Function: tests whether node1 and node2 are siblings
Returns : 1 if true, 0 if false
Args : second node

adopt

Title : adopt
Usage : $parent->adopt($child, $overwrite_children);
Function: make a parent-child relationship between two nodes
Returns : none
Args : the child node, boolean clobber flag

combine

Title : combine
Usage : my $newblock = $node->combine($child);
Function: removes a node from the tree, effectively by sliding its only child up the branch to its former position
Returns : none
Args : the child node
Methods : Combines the child node and the current node by assigning the
name, bootstrap value, children and other properties of the child. The branch length
of the current node is added to the child nodes branch length.

set_depth

Title : set_depth
Usage : $root->set_depth();
Function: Determines depth in tree of every node below this one
Returns : none
Args : This nodes depth

get_depth

Title : get_depth
Usage : $depth = $node->get_depth();
Function: Returns the nodes depth (number of generations removed from the root) in tree
Returns : integer representing nodes depth
Args : none

find_lengths

Title : find_lengths
Usage : $cladogram = 1 unless $root->find_lengths();
Function: Tries to determine if branch lengths are present in the tree
Returns : 1 if lengths are found, 0 if not
Args : none

mrca

Title : mrca
Usage : $mrca = $otu1-> mrca($otu2, $treename);
Function: Finds most recent common ancestor of otu1 and otu2
Returns : Node object of most recent common ancestor
Args : Nexus object, two otu objects, name of tree to look in

XML::LibXML::Node is an abstract base class of XML::LibXML nodes.

SYNOPSIS

$name = $node->nodeName;
$node->setNodeName( $newName );
$bool = $node->isSameNode( $other_node );
$bool = $node->isEqual( $other_node );
$content = $node->nodeValue;
$content = $node->textContent;
$type = $node->nodeType;
$node->unbindNode();
$childnode = $node->removeChild( $childnode );
$oldnode = $node->replaceChild( $newNode, $oldNode );
$node->replaceNode($newNode);
$childnode = $node->appendChild( $childnode );
$childnode = $node->addChild( $chilnode );
$node = $parent->addNewChild( $nsURI, $name );
$node->addSibling($newNode);
$newnode =$node->cloneNode( $deep );
$parentnode = $node->parentNode;
$nextnode = $node->nextSibling();
$prevnode = $node->previousSibling();
$boolean = $node->hasChildNodes();
$childnode = $node->firstChild;
$childnode = $node->lastChild;
$documentnode = $node->ownerDocument;
$node = $node->getOwner;
$node->setOwnerDocument( $doc );
$node->insertBefore( $newNode, $refNode );
$node->insertAfter( $newNode, $refNode );
@nodes = $node->findnodes( $xpath_expression );
$result = $node->find( $xpath );
print $node->findvalue( $xpath );
@childnodes = $node->childNodes;
$xmlstring = $node->toString($format,$docencoding);
$c14nstring = $node->toString($with_comments, $xpath_expression);
$str = $doc->serialze($format);
$c14nstr = $doc->serialize_c14n($comment_flag,$xpath);
$localname = $node->localname;
$nameprefix = $node->prefix;
$uri = $node->namespaceURI();
$boolean = $node->hasAttributes();
@attributelist = $node->attributes();
$URI = $node->lookupNamespaceURI( $prefix );
$prefix = $node->lookupNamespacePrefix( $URI );
$iter = $node->iterator;
$node->normalize;
@nslist = $node->getNamespaces;
$node->removeChildNodes();
$node->nodePath();
$lineno = $node->line_number();

XML::LibXML::Node defines functions that are common to all Node Types. A LibXML::Node should never be created standalone, but as an instance of a high level class such as LibXML::Element or LibXML::Text. The class itself should provide only common functionality. In XML::LibXML each node is part either of a document or a document-fragment. Because of this there is no node without a parent. This may causes confusion with "unbound" nodes.

polld is a simple daemon that periodically opens files defined in /etc/polld.
polld project can be used for scanning partitions in a card reader that does not report card insertion and removal.
I use this for scanning partitions in card reader, which does not report card
insertion/removal. With polld, they appear in 10 seconds after insertion and
udev will then create appripriate device nodes.
Enhancements:
- New release.
- Use LSB init script.