fastcgi
fastcgi++ 1.2
fastcgi++ provides you with an excellent and easy-to-use fastcgi++. more>>
fastcgi++ 1.2 provides you with an excellent and easy-to-use fastcgi++ library started out as a C++ alternative to the official FastCGI developers kit. It is released under the GNU Lesser General Public License.
Although the official developers kit provided some degree of C++ interface, it was very limited. The goal of this project was to provide a framework that offered all the facilities that the C++ language has to offer. Over time the scope broadened to the point that it became more than just a simple protocol library, but a platform to develop web application under C++.
To the dismay of many, this library has zero support for the old CGI protocol. The consensus was that if one were to be developing web applications under C++, efficient memory management and CPU usage would be a top priority, not CGI compatibility.
Major Features:
- Effective management of simultaneous requests without the need for multiple threads is something that fastcgi++ does best.
- Session data is organized into meaningful data types as opposed to a series of text strings. Internationalization and Unicode support is another top priority.
- The library is templated to allow internal wide character use for efficient text processing while code converting down to utf-8 upon transmission to the client.
Enhancements:
- Fixed bug in parsing post data
- Fixed buffer flushing bug
fastcgi-gallery 0.2.1
FastCGI Gallery is a Web gallery based on Apache::Gallery, but is hacked for usage with Perl FastCGI scripts. more>>
Therefore this version is about 10x quicker than Apache::Gallery. With best template system (Template-Toolkit) you can customize your gallery as you wish, for example you can create multilanguage gallery like this.
A database is not used; everything is stored in files. Output and generated thumbnails are cached for speed optimization.
Enhancements:
- A bug in the translation function when more than 2 languages were used has been fixed.
- A bug with files other than *.jpg has been fixed.
- Some W3C errors have been fixed.
mod_fcgid 2.2
mod_fcgid has a new process management strategy, which concentrates on reducing the number of fastcgi server. more>>
Binary compatibility to mod_fastcgi
You dont need to recompile your existing fastcgi programs, what you need to do is install the module and make it work.
Strict control on process spawn
Every request handler of Apache (It may be a process, or a thread, depending on the MPM) knows about how many existing fastcgi servers are running (with the help of share memory) , and the request handlers collaborate with each other to make sure over-spawning is not going to happen.
Simple spawning-speed control strategy
Its a score-based strategy, the score increases while a process is spawned or terminated, and decreases as time progresses;while the score is higher than the score maximum,the spawning will be held. Thus it can make a prompt response to the requests especially when the system starts up: on the other hand, prevent the failure resulted from the immediate termination of the applications.
Fastcgi server error detection
The fastcgi server does not share the same UNIX domain socket (or named pipe, in Windows), every fastcgi server has a unique path listening on. That makes it easy to kick out the corrupt fastcgi server.
Portable
Use the Apache APR library as much as possible, and split the portable and un-portable source code. All un-portable code are organized in arch directory. Now the module is tested on Linux, FreeBSD( included in FreeBSD port now), Windows 2000 and Solaris.
PHP supported
PHP is NOT recommended to work with multithreaded Apache2(worker MPM and WinNT MPM, for example), because some PHP extensions( or 3rd party library they are using) are not guaranteed thread-safe. PHP running with FastCGI mode is a solution to this problem.
RearSite 0.1
RearSite is a simple collaborative Web site manager. more>>
An administrator can create users accounts (user name, user passwd, and user home directory), users get logged in and then receive access to their documents.
RearSite is written in PERL (CGI.pm based) and use a FastCGI compliant HTTP server (like APACHE).
Using RearSite is quite simple : after login, the user has access to his home dir and is able to delete, rename, create and edit documents. RearSite is well adapted to install WWW directories previously cooked (using any editors). Its very easy to transfer and install archives (ZIP, tar or tar.gz by now), they are automatically unpacked.
Published documents are public (by default), access restriction may be done using user/password couples, DNS domains or LDAP filters.
The user interface is WWW forms like, so RearSite only needs (on the client side) a Java, JavaScript and frames compliant WWW browser (accepting cookies).
RearSite is now quite secured, the login process (developped in Java) use an MD5 encryption of the user password (combined with a one time key). So, people spying the network cannot use the keys they may have seen. After login, users receive a cookie associated with their computers IP numbers.
RearSite also allows the user to specify who can retrieve his documents by configuring access rights :
documents are public (the default).
documents are restricted to users coming from trusted domains.
documents are restricted to users coming from trusted domains or to HTTP authenticated users.
* documents are restricted to class of users existing in an LDAP directory. This kind of HTTP client authentication needs auth_ldap for Apache (See restricted access by users classes).
Since 1.1, if the administrator wants it, the user is able to use templates to specify per directories access rights. By default (and as an example), the user can easily say that a directory is public, for frenchies only or for frenchies excepted those in the ripoux.fr domain (french joke!).
The user is also able to share his directories with other RearSite users (trusted users). When a directory is shared, a trusted user user is able to delete, rename, add ... files within the directory he received rights for.
The user is also able to recursively process all the file names of all his embeded directories. The functionality provided is to rename all files (lowercase, replace a string within all file names, ...) which simplyfies migration from systems with case-insensitive file names. These functionalities are available by selecting the Special tools button which also give a way to export the current directory within an archive (ZIP or tar.gz).
Since 1.4, a forum can directly be attached to each directories. When a user wants to create a forum, the result is a Forum.html file located within the current directory. This file will give access to the forum. People having access to this file are allowed to post in the forum.
Since 1.6, a chat can directly be attached to each directories. When a user wants to create a chat, the result is a Chat.html file located within the current directory. This file will give access to the chat. People having access to this file are allowed to talk in the chat.
Since 1.9, a shareable calendar can be directly attached to each directories. When a user wants to create a calendar, the result is a Calendar.html file located within the current directory. This file will give access to the calendar. People having access to this file are allowed to read the calendar. Only the owner of a calendar is allowed to update it, but he may allow other users. Accessing his calendar via RearSite allows the owner to update it immediatly. When accessing a calendar via a normal WWW access, the user (owner or not) must be authenticated (via Rearsite configured authentication scheeme) before being allowed to update it.
The chat,forum and calendar functionalities are accessible via the Communications button, they have been designed for distance learning purposes but can easily be used for any groupware needs.
FCGI::ProcManager 0.17
FCGI::ProcManager is a Perl module with functions for managing FastCGI applications. more>>
SYNOPSIS
{ # In Object-oriented style. use CGI::Fast; use FCGI::ProcManager; my $proc_manager = FCGI::ProcManager->new({ n_processes => 10 }); $proc_manager->pm_manage(); while (my $cgi = CGI::Fast->new()) { $proc_manager->pm_pre_dispatch(); # ... handle the request here ... $proc_manager->pm_post_dispatch(); }
# This style is also supported:
use CGI::Fast;
use FCGI::ProcManager qw(pm_manage pm_pre_dispatch
pm_post_dispatch);
pm_manage( n_processes => 10 );
while (my $cgi = CGI::Fast->new()) {
pm_pre_dispatch();
#...
pm_post_dispatch();
}
FCGI::ProcManager is used to serve as a FastCGI process manager. By re-implementing it in perl, developers can more finely tune performance in their web applications, and can take advantage of copy-on-write semantics prevalent in UNIX kernel process management. The process manager should be invoked before the callers request loop
The primary routine, pm_manage, enters a loop in which it maintains a number of FastCGI servers (via fork(2)), and which reaps those servers when they die (via wait(2)).
pm_manage provides too hooks:
C< managing_init > - called just before the manager enters the manager loop.
C< handling_init > - called just before a server is returns from C< pm_manage >
It is necessary for the caller, when implementing its request loop, to insert a call to pm_pre_dispatch at the top of the loop, and then 7pm_post_dispatch at the end of the loop.
Rails 1.1
Rails is a full-stack framework for developing database-backed web applications according to the Model-View-Control pattern. more>>
From the Ajax in the view, to the request and response in the controller, to the domain model wrapping the database, Rails gives you a pure-Ruby development environment. To go live, all you need to add is a database and a web server.
Everyone from startups to non-profits to enterprise organizations are using Rails. Rails is all about infrastructure so its a great fit for practically any type of web application Be it software for collaboration, community, e-commerce, content management, statistics, management, you name it.
Rails works with a wealth of web servers and databases. For web server, we recommend Apache or lighttpd running either FastCGI or SCGI. For database, you can use MySQL, PostgreSQL, SQLite, Oracle, SQL Server, DB2, or Firebird. Just about any operating system will do, but we recommend a nix-based one for deployment.
If you need hosting, TextDrive is the official Ruby on Rails host, offering fantastic plans with a knowledgeable staff. Whether you need shared or dedicated hosting, these guys are experts in Ruby on Rails.
Creating a weblog in 15 minutes
In 15 minutes, we go from scratch to complete weblog engine: with comments and an administrative interface. But since the actual application only took 58 lines to complete, we also have time left over to do unit testing, examine the logs, and play around with the domain model.
Putting Flickr on Rails
Ruby on Rails is not just for playing with your local database, its for taking on the web. So in 5 minutes, we create a web-based search engine for Flickr using their public API with all the fades and glamour of Ajax. Hows that for a low-tech alternative to something fancy like Flash.
Evolving your database schema without a sweat
Before you know it, youll have data that you care about in your application. Which makes adding, removing, or changing the schema an error-prone, time-consuming, and frustrating process. That is, unless youre using Ruby on Rails. In 20 minutes, youll learn all about how database migrations can make your schema as flexible as your code with no fear of data loss.
FinScribe 0.7
FinScribe is a flexible Web authoring application which provides wiki and weblog. more>>
FinScribe was written as a technology demonstration for the Fins web application framework, FinScribe has grown into a full featured application that offers the best features of many different applications in one easy to use package.
FinScribe (and indeed, the whole underlying Fins framework) was born out of a desire to replace SnipSnap as the engine for this website. While it was (and is) a wonderful application, SnipSnap had a few very bad habits, such as eating a large amount of RAM and being rather slow. Additionally, SnipSnaps development pace had slowed considerably, leaving me to wonder if the shortcomings Id encountered would be fixed or improved in a timely manner.
After approximitely a week of development, FinScribe replaced SnipSnap on this website, and we havent looked back since. Weve made a large number of enhancements since then, and hope to continue the current pace of development in the future.
Note: There is no SnipSnap code in FinScribe, though the CSS stylesheets shipped with FinScribe are very slightly modified versions of those included with SnipSnap.
This is primarily due to the fact that this application was designed to be at least partially compatible with SnipSnap. As things continue to develop, well probably replace the stylesheets with something more original.
Main features:
- Flexible Wiki engine using SnipSnap compatible markup
- Weblog functionality
- Multiple Weblogs per application (each page may be a weblog)
- Multi-user capable
- Per-object Comments
- Extendible via Plugins (both wiki markup and application level macros)
- Produces RSS 2.0 feeds for Weblogs
- Includes an RSS 0.92/1.0/2.0 feed reader
- Category support
- Attachment support
- User administration
- User self-registration
- Skinnable interface using CSS
- Versioning capability (new versions are created upon object saves)
- Deployable as a standalone web server, as a module within Caudium, or using [external]FastCGI (tested with Apache).
Htscanner 0.8.1
Htscanner will allow one to use htaccess-like file to configure PHP per directory, just like apaches htaccess. more>>
This package was originally developed by Bart Vanbrabant. Old versions are available from: http://files.zoeloelip.be/htscanner
Albatross 1.36
Albatross is a small and flexible Python toolkit for developing highly stateful web applications. more>>
The toolkit has been designed to take a lot of the pain out of constructing intranet applications although you can also use Albatross for deploying publicly accessed web applications.
In slightly less than 2600 lines of Python (according to pycount), you get the following:
An extensible HTML templating system similar to DTML that promotes separation of presentation and implementation for improved program maintainability. The templating system includes tags for:
- Conditional processing,
- Macro definition and expansion,
- Sequence iteration and pagination,
- Tree browsing,
Lookup tables to translate Python values to arbitrary template text. The ability to place Python code for each page in a dynamically loaded module, or to place each page in its own class in a single mainline.
Optional sessions, which can be either:
- Browser based sessions via automatically generated hidden form fields (cryptographically signed to ensure integrity),
- Server-side sessions via a supplied TCP session server,
- Server-side file based session store.
Applications that can be deployed as either CGI programs or as mod_python module with minor changes to program mainline. Custom deployment can be achieved by developing your own Request class.
Over 120 pages of documentation including many installable samples. A primary design goal of Albatross is that it be small and easy to use and extend. The toolkit application functionality is defined by a collection of fine grained mixin classes. Eight different application types and four different execution contexts are prepackaged, allowing you to define your own drop in replacements for any of the mixins to alter any aspect of the toolkit semantics.
Object Craft developed Albatross because there was nothing available with the same capabilities which they could use for consulting work. For this reason the toolkit is important to Object Craft and so is actively maintained and developed.
Albatross is licensed under a liberal BSD open-source license.
Enhancements:
- Improvements and fixes were made to < al-for >, < al-macro >, < al-option >, NameRecorderMixin, and the FastCGI driver.
Gitarella 0.003
Gitarella project aim to provide a more performant, complete and friently Web frontend for GIT other than gitweb. more>>
The current version supports the basic browsing of repositories and diffing of files, and uses memcached as a backend for short-term storage of extracted data.
The development is handled through GIT at the url git://farraugt.flameeyes.is-a-geek.org/gitarella.git . Web interface is available on gitarella itself.
Version 0.001 is a pre-alpha version, that shows the current status of the code, it does work for basic browsing.
Enhancements:
- This version features lots of bugfixes, especially in handling of tags, remote (pushed) branches, and commit descriptions.
- It also adds graceful and not-entirely-graceful handling of exceptions (depending whether they are thrown during the initialisation phase or during the request) so that the user is never (or should never, at least) presented with an unanswered request.
- It makes the ruby-filemagic extension optional, although recommended, and make use of log4r extension for logging ability.
Egg::Release 1.20
Egg::Release is a Perl module for WEB application framework release version. more>>
Egg imitated and developed Catalyst.
It is WEB application framework of a simple composition.
It is possible to use it by replacing Model, View, Plugin, Engine, and Dispatch with the module of original development. It is a feature that the customizing degree of freedom is high.
The treatment of Plugin looks like Catalyst well.
Version View to use HTML::Mason from Egg::Release-1.00 was enclosed. I think that it can use a flexible, strong template environment.
It came to be able to set the label of each action by dispatch. The label is convenient to make page title and Topic Path.
It corresponds to FastCGI more than v1.04. Please see the document of Egg::Request::FastCGI about use.
Abyss Web Server X1 2.6
Abyss Web Server X1 is a free and compact Web server. It supports SSL, compression, CGI/FastCGI, ISAPI, XSSI, URL rewriting,bandwidth throttling, anti-leeching, anti-hacking, and features a remote web management interface. more>> <<less
Spyce - Python Server Pages 2.1.3
Spyce - Python Server Pages is a Python-based dynamic HTML server engine. more>>
Those who are familiar with JSP, PHP, or ASP and like Python, should have a look at Spyce. Its modular design makes it very flexible and extensible. Spyce - Python Server Pages can also be used as a command-line utility for static text pre-processing or as a web-server proxy.
The supported adapters are:
* Fast CGI:The default Spyce integration with Apache is acheived via FastCGI, a CGI-like interface that is relatively fast, because it does not incur the large process startup overhead on each request.
* mod_python: If you really must have the fastest Spyce implementation (see the performance numbers), it is currently through an Apache module called mod_python. Spyce has been tested with mod_python version 2.7.6 (and version 3.0.3 with apache 2.0.37). You can try to find some mod_python rpms here, but in general one must compile mod_python from sources. The reason for this is because mod_python links with the Python library it finds on your system at compile time. Thus, even if you have the correct Python version installed on your system, mod_python will be using the Python library version on the system where it was compiled. Also, note that mod_python (or rather Apache) needs a Python that has been compiled without threading, so you may need to recompile Python as well for this reason. The process is not very difficult (just the usual: ./configure; make; make install dance), but hopefully someone will suggest a better route in time. In any case, make sure you can first get mod_python running on your system, if that is that is your chosen Apache integration route.
* Web server: Another fast alternative is to serve Spyce files via a proxy. This involves running Spyce in web-server mode, and configuring the main web server to forward the appropriate requests. The built-in Spyce web server can also be used to serve requests directly, but this is highly discouraged for production environments.
* CGI: Failing these alternatives you can always process requests via regular CGI, but this alternative is the slowest option and is intended primarily for those who do not have much control over their web environments.
* Command line: Lastly, one can use Spyce as a command-line tool for pre-processing Spyce pages and creating static HTML files.
HTML::CMTemplate 0.4.0
HTML::CMTemplate.pm is a Perl module that can generate text-based content from templates. more>>
SYNOPSIS
use HTML::CMTemplate;
$t = new HTML::CMTemplate( path => [ /path1, /longer/path2 ] );
$t->import_template(
filename => file.html.ctpl, # in the paths above
packagename => theTemplate,
importrefs => { myvar => hello },
importclean => { myclean => clean! },
);
theTemplate::cleanup_namespace();
print "Content-type: text/htmlnn";
print theTemplate::output();
# Template syntax is described below -- see that section to get the real
# details on how to use this sucker.
HTML::CMTemplate 0.4.0
A class for generating text-based content from a simple template language. It was inspired by the (as far as Im concerned, incomplete) HTML::Template module, and was designed to make template output extremely fast by converting a text/html template into a dynamic perl module and then running code from that module. Since the parsing happens only once and the template is converted into Perl code, the output of the template is very fast.
It was designed to work with mod_perl and FastCGI and has been the basis for all of the dynamic content on the Orangatango site (http://www.orangatango.com).
First release (version 0.1) was February 15, 2001 and was very quiet because it was a proprietary version.
As of version 0.2, it is released under the Artistic License. Its a much more feature-rich version as well as being Open Source! For a copy of the Artistic License, see the files that came with your Perl distribution.
The code was developed during my time at Orangatango. It has been released as open source with the blessing of the controlling entities there.
Nanoweb 2.2.8
Nanoweb is a modular Web server written in PHP. more>>
Main features:
- HTTP/1.1 compliance
- Powerful and easy configuration
- Modular architecture
- FastCGI, CGI and Server side includes support
- Name and port based virtual hosts
- Access control lists
- htpasswd, MySQL, PostgreSQL and LDAP authentication support
- Themes for server generated content
- Apache compatible log format, MySQL logging
- Directory browsing
- inetd support and SSL via external helpers
- Denial of Service protection
- Proxy Server extension
- Filters and gzip support
- RBL support (mail-abuse.org)
- Extension Protocols (request methods) support
- and a lot more
- Page: 1 of 2
- 1
- 2