Free international virtual observatory software for linux

The Linux Virtual Server is a highly scalable and highly available server built on a cluster of real servers, with the load balancer running on the Linux operating system.

The architecture of the server cluster is fully transparent to end users, and the users interact as if it were a single high-performance virtual server.

The basic goal of the Linux Virtual Server Project is to:
- Build a high-performance and highly available server for Linux using clustering technology, which provides good scalability, reliability and serviceability.

Virtual server monitor (vsmon) is a monitoring tool for Linux-VServer that gives a system administrator a global view of all vservers running on his park.
For now, it does not offer control over the vservers life cycle (e.g. provisioning, start, stop, and restart operations). To use vsmon, you must deploy one backend on each vserver host and one frontend, preferably in its own vserver.
Enhancements:
- The frontend was reworked to display a summary of all hosts.
- An owner can be assigned to each vserver.
- The backend can be used on hosts without Linux-VServers, and it no longer obtains IP addresses.
- The libdnet dependency was removed.
- The parsing of /proc/"pid"/stat now works for kernel 2.6.18.
- A Nagios plugin was added, which enables the use of the vsmon backend to monitor a host disk, memory, and swap.
- The plugin monitors all mount points according to an "intelligent" algorithm, which determines warning and critical thresolds as a function of the total size of the partition.

Network Virtual Terminal for Java is a library that can drive a terminal emulator connected to the application through a telnet session.

Usage:

The API consists of the interface nvt4j.Terminal . The implementation of this class is called nvt4j.impl.Terminal. To allow the user to connect to the application you need to listen for a tcp connection and then wrap a Terminal object around it:

ServerSocket serverSocket = new ServerSocket(8000);
Socket socket = serverSocket.accept();
Terminal terminal = new nvt4j.impl.Terminal(socket);

For example, to run the sample class Example.java from an xterm session, you can
do this:

user@localhost$ java -classpath nvt4j.jar Example &
user@localhost$ telnet localhost 8000

NVT4J uses the Telnet LINEMODE option to put the terminal driver (xterm in this case) in what the posix standard calls raw or non-canonical mode, so that it can receive all user inputs asap, instead of waiting for a new-line character.

Unfortunately in pure Java there is no way to put the operating system console in
raw mode. On Linux and similar systems this is done using the stty command, which is a native program which manipulates the terminal driver in the operating system.

Whats New in This Release:

First alpha release. This code is quite limited but it already provides the basic functions needed to drive a terminal emulator for Java, namely putting the terminal driver in raw mode, turning off the cursor and client-side echo, and detecting the size of the terminal emulator window.

This code has been tested only with xterm.

The Interreality project is a collection of Open Source, Free Software projects based on the Virtual Object System (VOS) platform. Virtual Object System projects goal is to develop a open platform for multi-user 3D virtual reality games, applications, and interactive, collaborative 3D virtual spaces. VOS is a powerful and generic network object framework designed to support a variety of high-performance applications. It is the basis for TerAngreal, a general-purpose browser application for entering and participating in 3D worlds.

The goal of the Parallel Virtual File System (PVFS) Project is to explore the design, implementation, and uses of parallel I/O. PVFS serves as both a platform for parallel I/O research as well as a production file system for the cluster computing community. PVFS is currently targeted at clusters of workstations, or Beowulfs.
The PVFS project is conducted jointly between The Parallel Architecture Research Laboratory at Clemson University and The Mathematics and Computer Science Division at Argonne National Laboratory.
Additional funding for the PVFS project comes from NASA Goddard Space Flight Center Code 930 and The National Computational Science Alliance through the National Science Foundations Partnerships for Advanced Computational Infrastructure.
Main features:
- Compatibility with existing binaries
- Ease of installation
- User-controlled striping of files across nodes
- Multiple interfaces, including a MPI-IO interface via ROMIO
- Utilizes commodity network and storage hardware
PVFS supports the UNIX I/O interface and allows existing UNIX I/O programs to use PVFS files without recompiling. The familiar UNIX file tools (ls, cp, rm, etc.) will all operate on PVFS files and directories as well. This is accomplished via a Linux kernel module which is provided as a separate package.
PVFS is easy to install. The Quick Start page describes how to set up a simple installation. Scripts and test applications are included to help with configuration, testing for correct operation, and performance evaluation.
PVFS stripes file data across multiple disks in different nodes in a cluster. By spreading out file data in this manner, larger files can be created, potential bandwidth is increased, and network bottlenecks are minimized. A 64-bit interface is implemented as well, allowing large (more than 2GB) files to be created and accessed.
Enhancements:
- fixes to build under redhat 2.4.20-20.9 kernel
- checks for missing headers on ancient 2.4 kernels
- removal of unused fields from metadata and control messages
- updated pvfsd rc file
- handle various combinations of redhat kernel patches
- fixes to kpvfsd that had previously been fixed in user space
- fix for sftp directory reading problems
- fix to avoid oopses on clients when bad errno values returned
- adjustments to deal wiht gcc 3.4.0 issues
- fixes to work with redhat 9
- fixes to compile kernel code for xx86_64
- updated logging intrastructure
- fixes to error reporting
- update of makefile in pvfs core
- fix to bug in pvfs_open.c where pcount < 0 caused errors
- removed duplicated code in mgr
- fix for problem with bvrecv() optimization
- more unused code removal
- adjustments to keep portland group compiler happy
- removed sd_path from metadata
- new iod.rc and mgr.rc files
- fixes to chmod
- fixes to get correct fs_ino back to clients
- multiple mtime fixes
- streamlined pvfs file detection
- shared library building
- fixed closing socket bug in iod
- reordered messaging in mgr to iods to improve concurrency
- rename fix
- improved metadata file checking
- do_access permission fixes
- fix for "iod out of space" client hang
- cleaner dead socket handling, including special handling of case where mgr would close fds that clients were using
- noninteractive mkmgrconf

High Level Virtual Machine is a toolkit for developing virtual machines for dynamic languages.
The High Level Virtual Machine is:
- Based on LLVM (Low Level Virtual Machine). LLVM is HLVMs sister project. HLVM gains tremendous capability from LLVM in the areas of code generation, bytecode storage, runtime execution, etc.
- Aimed at supporting dynamic languages such as Ruby, Python, Perl, Jython, Haskell, Prolog, etc.
- A complete compiler developers toolkit for creating new languages easily. To write a new compiler, language designers simply write a plugin that describes the language to HLVM and how to translate the grammar productions into HLVMs comprehensive Abstract Syntax Tree (AST). After that, HLVM handles all aspects of code generation, bytecode storage, XML translation, JIT execution or interpretation, and native compilation.
- A language interoperability framework. Because all front end compilers generate code in the same AST, they can interoperate. Use of the runtime library for common constructs (e.g. "string") allow even complex data types to be shared between languages. Users of HLVM can write complex programs in multiple languages and be assured the result can be executed efficiently.
- A code management system including code revisioning, interface versioning, automated recompilation, separation of workspaces, etc.
- Currently under development. Project started April 20th, 2006. Stay tuned to this web site for future developments.

This is a project to create 64-bit virtual CPU, create a 64 bit assembler for the CPU and then port C to it, and then create scripts to port GNU/Linux to it.
The aim is to run 64-bit Linux on common 8/16/32 bit CPUs in applications where speed is not an issue.
Enhancements:
- Added C code intended tor a PIC Preliminary documentation More updates to Gambas program