The goal of this project is to provide a system for storing and retrieving huge amounts of data, distributed among a large number of heterogenous server nodes, under a single virtual filesystem tree with a variety of standard access methods. Depending on the Persistency Model, dCache provides methods for exchanging data with backend (tertiary) Storage Systems as well as space management, pool attraction, dataset replication, hot spot determination and recovery from disk or node failures. Connected to a tertiary storage system, the cache simulates unlimited direct access storage space. Dataexchanges to and from the underlying HSM are performed automatically and invisibly to the user. Filesystem namespace operations may be performed through a standard nfs(2) interface.

shmux solves a fairly simple problem that can be addressed
with a few lines of shell or Perl. This may lead you to think that using
shmux is total overkill, but shmux is a powerful tool
that offers many time and life saving features, so read on!

• When used in a script:
  
  • Ability to define what is and what is not an error for the command
    being run (based on exit code and output content)

  • Output and exit codes are saved into files to facilitate use from a
    script.
• When used interactively (directly on the command line, or from
  within a script/wrapper):
  
  • Well formatted output
    
  • Standard error output displayed in bold
    
  • Real-time status shown
    
  • Ability to pause, resume, quit cleanly
    
  • Automatically pause on error, allowing the user to cleanly stop
    before more goes wrong

Tentakel has the following features:

• Parallel execution of commands on several hosts.
• Format strings that control how the output of the remote commands is about to be displayed and how the output of different hosts should be separated from each other.
• A powerful configuration file that can be used to define groups of hosts. Such groups can contain other groups. Each group can be assigned a remote method, a username and a format string.
• Easy extensibility to allow for different remote methods (currently only ssh and rsh are supported).

It does not try to be a complex Distributed Resource Management System (DRM) like the Sun Grid Engine or Condor. Tentakel aims to be useful mainly for administration purposes.

Git is distributed version control system focused on speed, effectivity and real-world usability on large projects. Its highlights include:

• Strong support for non-linear development. Git supports rapid and convenient branching and merging, and includes powerful tools for visualizing and navigating a non-linear development history.
• Distributed development. Like most other modern version control systems, Git gives each developer a local copy of the entire development history, and changes are copied from one such repository to another. These changes are imported as additional development branches, and can be merged in the same way as a locally developed branch. Repositories can be easily accessed via the efficient Git protocol (optionally wrapped in ssh) or simply using HTTP - you can publish your repository anywhere without any special webserver configuration required.
• Efficient handling of large projects. Git is very fast and scales well even when working with large projects and long histories. It is commonly an order of magnitude faster than most other revision control systems, and several orders of magnitude faster on some operations. It also uses an extremely efficient packed format for long-term revision storage that currently tops any other open source version control system.
• Cryptographic authentication of history. The Git history is stored in such a way that the name of a particular revision (a "commit" in Git terms) depends upon the complete development history leading up to that commit. Once it is published, it is not possible to change the old versions without it being noticed. Also, tags can be cryptographically signed.
• Toolkit design. Following the Unix tradition, Git is a collection of many small tools written in C, and a number of scripts that provide convenient wrappers. It is easy to chain the components together to do other clever things.

Besides providing a version control system, the Git project provides a generic low-level toolkit for tree history storage and directory content management. Traditionally, the toolkit is called the plumbing. Several other projects (so-called porcelains) offer compatible version control interfaces - see the related tools list.

The Carnegie Mellon NetReg package is a scalable and flexible Web-based system for managing networks. It consolidates information about DNS zones, subnets, machine registrations, and DHCP configuration, and provides tools for easy management. The system exports ISC BIND configuration and zones, and can update them via either static zone files or TSIG signed dynamic DNS updates. It also exports ISC DHCP configurations, and has a SOAP API for integration with other systems.

WPKG can add great value to your Samba or Active Directory setup, as it allows to perform software installation, updates, removal etc. on your workstations. It features dependencies and there is a windows service wich does all this on machine start, user logons can be delayed until wpkg has finished its work.

It is also possible to execute custom scripts on your workstations, like synchronizing time, setting printers, changing permissions or adding registry entries (basically, some of the things you would do with Active Directory and Group Policy / GPO).

Basically it is a set of XML files and a javascript program. There is a web-gui for package/machine management available at http://wpkg.linuxkidd.com/.

Bcfg2 is a generative configuration management system that can be used for management of aspects of client systems, complete control of client systems, and the range in between. Bcfg2 is designed to work well in pre-existing environments, and in the presence of manual administration.
Bcfg2's most interesting feature is a web frontend that presents client configuration conformance information to administrators. This provides administrators with a direct way to observe how good of a job they are doing describing how their network should look. To our knowledge, this approach is unique to bcfg2, both as a goal and as a supported operation.

NetDirector replaces ad hoc scripts for making configuration changes to many servers at the same time with a well-defined, consistent process.
Schedule Changes to happen anytime in the future
Rollback any change
NetDirector's built-in revision control makes life a lot easier
See who did what, when and what they did - NetDirector stores all change info in its database. Easily export audit trails
Use NetDirector's role-based permissions to enforce segregation of duties. When an Admin logs into NetDirector, they will only see, and can only configure, the servers and services on these servers that pertain to their role.
Group your servers in NetDirector however you want and then apply changes to all servers, to a group of servers, or to any combination of servers you want to. It's up to you.

A cross-platform Ruby library for retrieving facts from operating systems. Supports multiple resolution mechanisms, any of which can be restricted to working only on certain operating systems or environments. Facter is especially useful for retrieving things like operating system names, IP addresses, MAC addresses, and SSH keys.

It is easy to extend Facter to include your own custom facts or to include additional mechanisms for retrieving facts.

Puppet lets you centrally manage every important aspect of your system using a cross-platform specification language that manages all the separate elements normally aggregated in different files, like users, cron jobs, and hosts, along with obviously discrete elements like packages, services, and files.

Puppet's simple declarative specification language provides powerful classing abilities for drawing out the similarities between hosts while allowing them to be as specific as necessary, and it handles dependency and prerequisite relationships between objects clearly and explicitly. Puppet is written entirely in Ruby.