Ports Search

clone is a file tree cloning tool which runs 3 threads - a scheduler (main), a reader, and a writer thread. Reading and writing occurs in parallel. While this is most beneficial for copying data from one physical disk to another, clone is also very well suited for cloning a file tree to any place on the same disk. Cloning includes the whole directory hierarchy, i.e. sub-directories, files, hard links, symbolic links, attributes (modes, flags, times), extended attributes and access control lists. clone is useful for cloning (thus backing-up) live file systems, and it can also be used in incremental and synchronization mode. clone works on FreeBSD and Mac OS X. clone is very fast, for example, cloning a whole UFS2 file hierarchy on FreeBSD 9.1 of in total 2.3 TBytes of data from one hard disk to another took 7.5 h, so the average transfer rate for all kind of files (very small up to very big ones) was about 89 MByte/s.

Afuse is an automounting file system implemented in user-space using FUSE. Afuse currently implements the most basic functionality that can be expected by an automounter; that is it manages a directory of virtual directories. If one of these virtual directories is accessed and is not already automounted, afuse will attempt to mount a filesystem onto that directory. If the mount succeeds the requested access proceeds as normal, otherwise it will fail with an error. The advantage of using afuse over traditional automounters is that afuse is designed to run entirely in user-space by individual users. This way an automounting action can take advantage of the invoking users environment, for example allowing access to an ssh-agent for password-less sshfs mounts, or allowing access to a graphical environment to get user input to complete a mount (i.e. popping up a window asking for a password).

GNU cpio copies files into or out of a cpio or tar archive. The archive can be another file on the disk, a magnetic tape, or a pipe. GNU cpio supports the following archive formats: binary, old ASCII, new ASCII, crc, HPUX binary, HPUX old ASCII, old tar, and POSIX.1 tar. The tar format is provided for compatibility with the tar program. By default, cpio creates binary format archives, for compatibility with older cpio programs. When extracting from archives, cpio automatically recognizes which kind of archive it is reading and can read archives created on machines with a different byte-order. Note that this port will install these utilities with a 'g' prefix, e.g. gcpio, but the texinfo documentation will refer to them without the 'g' prefix.

Shake is a Haskell library for writing build systems - designed as a replacement for make. To use Shake the user writes a Haskell program that imports the Shake library, defines some build rules, and calls shake. Thanks to do notation and infix operators, a simple Shake program is not too dissimilar from a simple Makefile. However, as build systems get more complex, Shake is able to take advantage of the excellent abstraction facilities offered by Haskell and easily support much larger projects. The Shake library provides all the standard features available in other build systems, including automatic parallelism and minimal rebuilds. Shake provides highly accurate dependency tracking, including seamless support for generated files, and dependencies on system information (e.g. compiler version).

Media::Type::Simple gives a simple functions for obtaining common file extensions from media types, and from obtaining media types from file extensions. It is also relaxed with respect to having multiple media types associated with a file extension, or multiple extensions associated with a media type, and it includes media types for encodings such as gzip. It is defined this way in the default data, but this does not meet your needs, then you can have it use a system file (e.g. /etc/mime.types) or custom data. By default, there is a functional interface, although you can also use an object-oriented inteface. (Different objects will not share the same data.)

Unofficial Python API for retrieving data from Delicious.com. This module provides the following features plus some more: * retrieving a URL's full public bookmarking history including * users who bookmarked the URL including tags used for such bookmarks and the creation time of the bookmark (up to YYYY-MM-DD granularity) * top tags (up to a maximum of 10) including tag count * title as stored on Delicious.com * total number of bookmarks/users for this URL at Delicious.com * retrieving a user's full bookmark collection, including any private bookmarks if you know the corresponding password * retrieving a user's full public tagging vocabulary, i.e. tags and tag counts * retrieving a user's network information (network members and network fans) * HTTP proxy support * updated to support Delicious.com "version 2" (mini-relaunch as of August 2008)

PyChecker is a python source code checking tool to help you find common bugs. It is meant to find problems that are typically caught by a compiler. Because of the dynamic nature of python, some warnings may be incorrect; however, spurious warnings should be fairly infrequent. PyChecker works in a combination of ways. First, it imports each module. If there is an import error, the module cannot be processed. The import provides some basic information about the module. For each function, class, and method, the code within the function is checked for possible problems. Types of problems that can be found include: * No doc strings in modules, classes, functions, and methods * self not the first parameter to a method * Wrong number of parameters passed to functions/methods * No global found (e.g., using a module without importing it) * Global not used (module or variable)

Net::IP::Match::Regexp allows you to check an IP address against one or more IP ranges. It employs Perl's highly optimized regular expression engine to do the hard work, so it is very fast. It is optimized for speed by doing the match against a regexp which implicitly checks the broadest IP ranges first. An advantage is that the regexp can be computed and stored in advance (in source code, in a database table, etc) and reused, saving much time if the IP ranges don't change too often. The match can optionally report a value (e.g. a network name) instead of just a boolean, which makes module useful for mapping IP ranges to names or codes or anything else.

OpenConnect server (ocserv) is an SSL VPN server. Its purpose is to be a secure, small, fast and configurable VPN server. It implements the OpenConnect SSL VPN protocol, and has also (currently experimental) compatibility with clients using the AnyConnect SSL VPN protocol. The OpenConnect protocol provides a dual TCP/UDP VPN channel, and uses the standard IETF security protocols to secure it. Both IPv4 and IPv6 are supported. Ocserv's main features are security through provilege separation and sandboxing, accounting, and resilience due to a combined use of TCP and UDP. Authentication occurs in an isolated security module process, and each user is assigned an unprivileged worker process, and a networking (tun) device. That not only eases the control of the resources of each user or group of users, but also prevents data leak (e.g., heartbleed-style attacks), and privilege escalation due to any bug on the VPN handling (worker) process. A management interface allows for viewing and querying logged-in users.

This module implements a scalable method of quickly propagating files to a large number of servers in one or more locations via rsync or scp. This module and the included script, ccp, take a much more efficient approach that is O(log n). Once the file(s) are been copied to a remote server, that server will be promoted to be used as source server for copying to remaining servers. Thus, the rate of transfer increases exponentially rather than linearly. Servers can be specified in groups (e.g. datacenter) to prevent copying across groups. This maximizes the number of transfers done over a local high-speed connection (LAN) while minimizing the number of transfers over the WAN. The number of multiple simultaneous transfers per source point is configurable. The total number of simultaneously forked processes is limited via Proc::Queue, and is currently hard coded to 32.