uWSGI
  • Quickstart for Python/WSGI applications
    • Installing uWSGI with Python support
    • The first WSGI application
    • Deploy it on HTTP port 9090
    • Adding concurrency and monitoring
    • Putting behind a full webserver
    • Automatically starting uWSGI on boot
    • Deploying Django
    • Deploying Flask
    • Deploying web2py
    • A note on Python threads
    • Virtualenvs
    • Security and availability
    • Offloading
    • And now
  • Quickstart for perl/PSGI applications
    • Installing uWSGI with Perl support
    • Note for distro packages
    • Your first PSGI app
    • What is that ‘–http-modifier1 5’ thing ???
    • Using a full webserver: nginx
    • Adding concurrency
    • Adding robustness: the Master process
    • Using config files
    • Automatically starting uWSGI on boot
    • Security and availability
    • Offloading
    • And now
  • Quickstart for ruby/Rack applications
    • Installing uWSGI with Ruby support
    • Note for distro packages
    • Your first Rack app
    • What is that ‘–http-modifier1 7’ thing ???
    • Using a full webserver: nginx
    • Adding concurrency
    • Adding robustness: the Master process
    • Using config files
    • The fork() problem when you spawn multiple processes
    • Deploying Sinatra
    • Deploying RubyOnRails >= 3
    • Deploying older RubyOnRails
    • Bundler and RVM
    • Automatically starting uWSGI on boot
    • Security and availability
    • Memory usage
    • Offloading
    • And now
  • Snippets
    • X-Sendfile emulation
    • Force HTTPS
    • Python Auto-reloading (DEVELOPMENT-ONLY !!!)
  • Getting uWSGI
  • Installing uWSGI
    • Installing from a distribution package
    • Installing from source
    • Alternative build profiles
    • Modular builds
  • The uWSGI build system
    • uwsgiconfig.py
    • build profiles
    • First example
    • CC and CPP
    • CPUCOUNT
    • UWSGI_FORCE_REBUILD
    • Plugins and uwsgiplugin.py
    • UWSGI_INCLUDES
    • UWSGI_EMBED_PLUGINS
    • UWSGI_EMBED_CONFIG
    • UWSGI_BIN_NAME
    • CFLAGS and LDFLAGS
    • UWSGICONFIG_* for plugins
    • libuwsgi.so
    • uwsgibuild.log
    • uwsgibuild.lastcflags
    • cflags and uwsgi.h magic
    • embedding files
    • The fake make
  • Managing the uWSGI server
    • Starting the server
    • Signals for controlling uWSGI
    • Reloading the server
    • Stopping the server
    • The Master FIFO
  • Supported languages and platforms
  • Supported Platforms/Systems
  • Web server integration
    • Cherokee
    • Nginx
    • Apache
    • Mongrel2
    • Lighttpd
    • Twisted
    • Tomcat
    • CGI
  • Frequently Asked Questions (FAQ)
    • Why should I choose uWSGI?
    • What about the protocol?
    • Can I use it in cluster environments?
    • So, why all those timeout configuration flags?
    • I need help! What do I do?
    • I am not a sysadmin, nor a UNIX guru. Can I use uWSGI?
    • How can I buy commercial support for my company?
    • Will this allow me to run my awesome apps on my ancient close-minded ISP?
    • Where are the benchmarks?
    • Ha! Server XXX is faster than uWSGI! Take that!
    • What is ‘Harakiri mode’?
    • Will my app run faster with uWSGI?
    • What are the most important options for performance and robustness in the uWSGI environment?
    • Why not simply use HTTP as the protocol?
    • Why do you support multiple methods of configuration?
    • What is the best webserver handler?
  • Things to know (best practices and “issues”)
  • Configuring uWSGI
    • Loading configuration files
    • Magic variables
    • Placeholders
    • Placeholders math (from uWSGI 1.9.20-dev)
    • Command line arguments
    • Environment variables
    • INI files
    • XML files
    • JSON files
    • YAML files
    • SQLite configuration
    • LDAP configuration
  • Fallback configuration
    • Simple case
    • Broken apps
    • Multiple fallback levels
    • How it works
    • Notes
  • Configuration logic
    • for
    • if-env
    • if-exists
    • if-file
    • if-dir
    • if-opt
  • Configuration Options
    • Networking/sockets
    • Process Management
    • Process Management - Emperor
    • Process Management - Zerg
    • Debugging
    • Configuration
    • Config logic
    • Logging
    • Alarms
    • uWSGI Process
    • Miscellaneous
    • Locks
    • Cache
    • Queue
    • Spooler
    • Mules
    • Application loading
    • Request handling
    • Clustering
    • Subscriptions
    • Router
    • Static files
    • Clocks
    • Loop engines
    • Greenlet
    • Gevent
    • Stackless
    • uGreen
    • Fiber
    • CoroAE
    • tornado
    • Carbon
    • CGI
    • Busyness Cheaper algorithm
    • Erlang
    • Fastrouter
    • GeoIP
    • GlusterFS
    • Gccgo
    • Go_plugin
    • HTTP
    • HTTPS
    • JVM
    • Lua
    • Mono
    • Nagios output
    • PAM
    • Perl
    • PHP
    • Ping
    • PyPy
    • Python
    • Rawrouter
    • Ring
    • RRDtool
    • Rsyslog
    • Ruby
    • SSL Router
    • Symcall
    • WebDAV
    • XSLT
  • Defining new options for your instances
    • More fun: a bunch of shortcuts
    • A trick for the Emperor: automatically import shortcuts for your vassals
    • An advanced trick: embedding shortcuts in your uWSGI binary
  • How uWSGI parses config files
    • Expanding variables/placeholders
    • A note on magic variables
  • uwsgi protocol magic variables
    • UWSGI_SCHEME
    • UWSGI_SCRIPT
    • UWSGI_MODULE and UWSGI_CALLABLE
    • UWSGI_PYHOME
    • UWSGI_CHDIR
    • UWSGI_FILE
    • UWSGI_TOUCH_RELOAD
    • UWSGI_CACHE_GET
    • UWSGI_SETENV
    • UWSGI_APPID
  • The uwsgi Protocol
    • uwsgi packet header
    • Packet descriptions
    • The uwsgi vars
  • Managing external daemons/services
    • Kinds of services
    • Examples
    • Legion support
    • –attach-daemon2
  • The Master FIFO
    • Available commands
    • FIFO slots
    • Notes
  • Socket activation with inetd/xinetd
    • Inetd
    • Xinetd
  • Running uWSGI via Upstart
    • A simple script (/etc/init/uwsgi.conf)
    • Using the Emperor
    • What is –die-on-term?
    • Socket activation (from Ubuntu 12.04)
  • SystemD
    • Adding the Emperor to systemd
    • Logging
    • Putting sockets in /run/
    • Socket activation
  • Running uWSGI instances with Circus
    • Socket activation
    • (Better) Socket activation
  • Embedding an application in uWSGI
    • Step 1: creating the build profile
    • Step 2: embedding the config file
    • Step 3: embedding flask itself
    • Step 4: adding templates
  • Logging
    • Basic logging
    • Pluggable loggers
    • Log routing
    • Logging to files
    • Logging to sockets
    • Logging to syslog
    • Logging to remote syslog
    • Redis logger
    • MongoDB logger
    • ZeroMQ logging
    • Crypto logger (plugin)
    • Graylog2 logger (plugin)
    • Systemd logger (plugin)
    • Writing your own logger plugins
  • Formatting uWSGI requests logs
    • offsetof
    • functions
    • User-defined logvars
    • Apache-style combined request logging
    • Hacking logformat
  • Log encoders
    • Request logs VS stdout/stderr
    • Routing encoders
    • Core encoders
    • The msgpack encoder
    • Notes
  • Hooks
    • The uWSGI “hookable” phases
    • The “hardcoded” hooks
    • Attaching “hardcoded” hooks
    • The “advanced” hooks
  • Glossary
  • uWSGI third party plugins
    • uwsgi-capture
    • uwsgi-wstcp
    • uwsgi-pgnotify
    • uwsgi-quota
    • uwsgi-eventfd
    • uwsgi-console-broadcast
    • uwsgi-strophe
    • uwsgi-alarm-chain
    • uwsgi-netlink
    • uwsgi-pushover
  • The uWSGI Caching Cookbook
    • Let’start
    • The first recipe
    • Cache them all !!!
    • Multiple caches
    • Being more aggressive, the Expires HTTP header
    • Storing GZIP variant of an object
    • Storing static files in the cache for fast serving
    • Caching for authenticated users
    • Caching to files
  • Setting up Django and your web server with uWSGI and nginx
    • Some notes about this tutorial
    • Concept
    • Before you start setting up uWSGI
    • Basic uWSGI installation and configuration
    • Basic nginx
    • nginx and uWSGI and test.py
    • Using Unix sockets instead of ports
    • Running the Django application with uswgi and nginx
    • Configuring uWSGI to run with a .ini file
    • Install uWSGI system-wide
    • Emperor mode
    • Make uWSGI startup when the system boots
    • Further configuration
  • Running uWSGI on Dreamhost shared hosting
    • Preparing the environment
    • Preparing the python virtualenv
    • The .htaccess
    • Ready
    • The flock trick
    • Statistics
    • Running Perl/PSGI apps (requires uWSGI >= 1.9)
    • Running Ruby/Rack apps (requires uWSGI >= 1.9)
    • Serving static files
  • Running python webapps on Heroku with uWSGI
    • Preparing the environment
    • Creating the uWSGI config file
    • Preparing for the first commit/push
    • Checking your app
    • Using another version of python
    • Multiprocess or Multithread ?
    • Async/Greethreads/Coroutine ?
    • Harakiri
    • Static files
    • Adaptive process spawning
    • Logging
    • Alarms
    • The Spooler
    • Mules
    • Signals (timers, filemonitors, crons...)
    • External daemons
    • Monitoring your app (advanced/hacky)
  • Running Ruby/Rack webapps on Heroku with uWSGI
    • Preparing the environment (a Sinatra application)
    • Creating the uWSGI config file
    • Deploying to heroku
    • fork() for dummies
    • The ruby GC
    • Concurrency
    • Harakiri
    • Static files
    • Adaptive process spawning
    • Logging
    • Alarms
    • The Spooler
    • Mules
    • Signals (timers, filemonitors, crons...)
    • External daemons
  • Reliably use FUSE filesystems for uWSGI vassals (with Linux)
    • A Zip filesystem
    • Going Heavy Metal: A CoW rootfs (unionfs-fuse)
    • Notes
  • Build a dynamic proxy using RPC and internal routing
    • step 1: build your mapping function
    • step 2: building a routing table
  • Setting up Graphite on Ubuntu using the Metrics subsystem
    • Installing Graphite and the others needed packages
    • Initializing Graphite
    • Building and Installing uWSGI
    • Setting up the uWSGI Emperor
    • Spawning the Graphite web interface
    • Spawning vassals sending metrics to Graphite
    • Using Graphiti (Ruby/Sinatra based) as alternative frontend
    • Notes
  • Serializing accept(), AKA Thundering Herd, AKA the Zeeg Problem
    • select()/poll()/kqueue()/epoll()/...
    • Application Servers VS WebServers
    • How application server developers solved it
    • No-problem ??? So, again, what we are talking about ?
    • The Zeeg problem: Multiple processes with multiple threads
    • How David solved it ?
    • uWSGI docs sucks: –thunder-lock
    • SysV IPC semaphores are bad how you solved it ?
    • uWSGI developers are fu*!ing cowards
    • When SysV IPC semaphores are a better choice
    • What about other portable lock engines ?
    • Conclusions
    • Bonus chapter: using the Zeeg approach in a uWSGI friendly way
    • Bonus chapter 2: securing SysV IPC semaphores
    • Credits:
  • The Art of Graceful Reloading
    • What is a “graceful reload”?
    • Things go wrong
    • The listen queue
    • Proxy timeouts
    • Waiting instead of errors is good, no errors and no waiting is even better
    • Preforking VS lazy-apps VS lazy
    • Standard (default/boring) graceful reload (aka SIGHUP)
    • Workers reloading in lazy-apps mode
    • Chain reloading (lazy apps)
    • Zerg mode
    • The Zerg Dance: Pausing instances
    • SO_REUSEPORT (Linux >= 3.9 and BSDs)
    • The Black Art (for rich and brave people): master forking
    • Subscription system
    • Inconsistent states
    • Fighting inconsistent states with the Emperor
    • Dealing with ultra-lazy apps (like Django)
    • Finally: Do not blindly copy & paste!
    • References
  • Fun with Perl, Eyetoy and RaspberryPi
    • Intro
    • uWSGI subsystems and plugins
    • What we want to accomplish
    • Technical background
    • Let’s start: the uwsgi-capture plugin
    • Step 2: the PSGI app
    • Step 3: HTML5
    • Ready to watch
    • Concurrency
    • Zero-copy all over the place
    • Alternative approaches
    • Other languages
    • More hacking
  • The uWSGI alarm subsystem (from 1.3)
    • Embedded event monitors
    • Defining an alarm
    • Damnit, this... this is the rawest thing I’ve seen...
    • Protecting from bad rules
    • How does log-alarm work ?
    • Available plugins and their syntax
  • The uWSGI caching framework
    • Creating a “cache”
    • A sad/weird/strange/bad note about “the maximum number of items”
    • Configuring the cache (how it works)
    • Single block (faster) vs. bitmaps (slower)
    • Persistent storage
    • Network access
    • UDP sync
    • –cache2 options
    • Accessing the cache from your applications using the cache api
    • The Cache sweeper thread
    • Web caching
  • WebCaching framework
    • Persistent storage
    • Cache sweeper
    • Directly accessing the cache from your web server
    • Django cache backend
  • The uWSGI cron-like interface
    • uWSGI signal based
    • Timers vs. cron
    • Notes
    • Option-based cron
  • The uWSGI FastRouter
    • Getting started
    • Way 1: –fastrouter-use-base
    • Way 2: –fastrouter-use-pattern
    • Way 3: –fastrouter-use-cache
    • Way 4: –fastrouter-subscription-server
    • Way 5: –fastrouter-use-code-string
    • Cheap mode and shared sockets
    • Notes
  • uWSGI internal routing
    • The routing chains
    • The internal routing table
    • Action return values
    • The first example
    • Accessing request vars
    • Accessing cookies
    • Accessing query string items
    • Pluggable routing variables
    • Is –route-if not enough? Why –route-uri and friends?
    • GOTO
    • Collecting response headers
    • The available actions
  • The uWSGI Legion subsystem
    • IP takeover
    • cmd:<command>
    • signal:<num>
    • log:<msg>
  • Locks
  • uWSGI Mules
    • Basic usage
    • Giving a brain to mules
  • The uWSGI offloading subsystem
    • Offloading static files
    • Offloading internal routing
    • The Future
  • The uWSGI queue framework
    • Using the queue as a shared array
    • Using the queue as a shared stack
    • Using the queue as a FIFO queue
    • Notes
  • uWSGI RPC Stack
    • Learning by example
    • Doing RPC locally
    • Doing RPC from the internal routing subsystem
    • Doing RPC from nginx
    • HTTP PATH_INFO -> RPC bridge
    • XML-RPC -> RPC bridge
  • SharedArea – share memory pages between uWSGI components
    • Simple option VS keyval
    • The API
    • Waiting for updates
    • Optional API
    • Websockets integration API
    • Advanced usage (from C)
  • The uWSGI Signal Framework
    • The Signals table
    • Defining signal handlers
    • Raising signals
    • External events
    • signal_wait and signal_received
    • Todo
  • The uWSGI Spooler
    • Spool files
    • Setting the spooler function/callable
    • Enqueueing requests to a spooler
    • External spoolers
    • Networked spoolers
    • Priorities
    • Options
    • Tips and tricks
  • uWSGI Subscription Server
    • Securing the Subscription System
    • –subscribe2
  • Serving static files with uWSGI (updated to 1.9)
    • Mode 1: Check for a static resource before passing the request to your app
    • Mode 2: trust frontend’s DOCUMENT_ROOT
    • Mode 3: using static file mount points
    • Mode 4: using advanced internal routing
    • Setting the index page
    • MIME types
    • Skipping specific extensions
    • Setting the Expires headers
    • Transfer modes
    • GZIP (uWSGI 1.9)
    • Security
    • Caching paths mappings/resolutions
    • Bonus trick: storing static files in the cache
    • Notes
  • SNI - Server Name Identification (virtual hosting for SSL nodes)
    • Adding SNI objects
    • Adding complex SNI objects
    • Massive SNI hosting
    • Subscription system and SNI
  • The GeoIP plugin
    • Enabling geoip lookup
    • An example
    • Memory usage
  • uWSGI Transformations
    • Streaming vs. buffering
    • Flushing magic
    • Available transformations (last update 20130504)
    • Working on
  • WebSocket supports
    • An echo server
    • Handshaking
    • Sending
    • Receiving
    • PING/PONG
    • Available proxies
    • Languages support
    • Supported Concurrency models
    • wss:// (websockets over https)
    • Websockets over SPDY
    • Routing
    • Api
  • The Metrics subsystem
    • Metric names and oids
    • Metric types
    • Metric collectors
    • Custom metrics
    • The metrics directory
    • Restoring metrics (persistent metrics)
    • API
    • Stats pushers
    • Alarms/Thresholds
    • SNMP integration
    • Internal Routing integration
    • Request logging
    • Officially Registered Metrics
    • OID assigment for plugins
    • External tools
  • The Chunked input API
    • Reading chunks
    • Tuning the chunks buffer
    • Integration with proxies
    • Options
    • Notes
  • The uWSGI cheaper subsystem – adaptive process spawning
    • Usage
    • Setting memory limits
    • spare cheaper algorithm
    • backlog cheaper algorithm
    • cheaper busyness algorithm
  • The uWSGI Emperor – multi-app deployment
    • Imperial monitors
    • The Emperor protocol
    • Special configuration variables
    • Passing configuration parameters to all vassals
    • Tyrant mode (secure multi-user hosting)
    • On demand vassals (socket activation)
    • Loyalty
    • Throttling
    • Blacklist system
    • Heartbeat system
    • Using Linux namespaces for vassals
    • The Imperial Bureau of Statistics
    • Running non-uWSGI apps or using alternative uWSGIs as vassals
    • Integrating the Emperor with the FastRouter
    • Notes
    • Todo
  • Auto-scaling with Broodlord mode
    • A simple example
  • Zerg mode
    • Enabling the zerg server
    • Attaching zergs to the zerg server
    • Fallback if a zerg server is not available
    • Using Zerg as testers
    • Zerg Pools
  • Adding applications dynamically
    • Defining VirtualEnv with dynamic apps
  • Scaling SSL connections (uWSGI 1.9)
    • Setup 1: using the uWSGI cache for storing SSL sessions
    • Setup 2: synchronize caches of different HTTPS routers
    • Using named caches
    • Notes
  • Setting POSIX Capabilities
    • Available capabilities
  • Running uWSGI in a Linux CGroup
    • Enabling cgroups
    • A real world example: Scheduling QoS for your customers
  • Using Linux KSM in uWSGI
    • Enabling the KSM daemon
    • Enabling KSM support in uWSGI
    • Performance impact
    • Check if KSM is working well
  • Jailing your apps using Linux Namespaces
    • What are namespaces?
    • clone() vs unshare()
    • Supported namespaces
    • setns()
    • pivot_root
    • Why not lxc ?
  • The old way: the –namespace option
    • Reloading uWSGI
    • How secure is this sort of jailing?
    • Additional filesystems
  • FreeBSD Jails
    • Why managing jails with uWSGI ?
    • Old-style jails (FreeBSD < 8)
    • New style jails (FreeBSD >= 8)
    • DevFS
    • Reloading
    • The jidfile
    • Attaching to a jail
    • Debian/kFreeBSD
    • Jails with Forkpty Router
    • Notes
  • The Forkpty Router
    • uwsgi mode VS raw mode
    • Running the forkpty router
    • Changing the default command
  • The TunTap Router
    • The first config
    • The embedded firewall
    • Security
    • The Future
  • Monitoring uWSGI with Nagios
    • Setting warning messages
  • The embedded SNMP server
    • Exporting custom values
  • Pushing statistics (from 1.4)
    • The ‘file’ stats pusher
    • The ‘mongodb’ stats pusher
    • Notes
  • Integration with Graphite/Carbon
    • Quickstart
  • The uWSGI Stats Server
    • uwsgitop
  • The Metrics subsystem
    • Metric names and oids
    • Metric types
    • Metric collectors
    • Custom metrics
    • The metrics directory
    • Restoring metrics (persistent metrics)
    • API
    • Stats pushers
    • Alarms/Thresholds
    • SNMP integration
    • Internal Routing integration
    • Request logging
    • Officially Registered Metrics
    • OID assigment for plugins
    • External tools
  • uWSGI asynchronous/non-blocking modes (updated to uWSGI 1.9)
    • Glossary
    • Async switches
    • Running uWSGI in Async mode
    • Waiting for I/O
    • Sleeping
    • Suspend/Resume
    • Static files
  • The Gevent loop engine
    • Notes
    • Building the plugin (uWSGI >= 1.4)
    • Building the plugin (uWSGI < 1.4)
    • Running uWSGI in gevent mode
    • A crazy example
    • Monkey patching
    • Notes on clients and frontends
  • The Tornado loop engine
    • Why ?
    • Installation
    • Running it
    • Integrating WSGI with the tornado api
    • Welcome to Callback-Hell
    • WSGI generators (aka yield all over the place)
    • Binding and listening with Tornado
  • uGreen – uWSGI Green Threads
    • Security and performance
    • Async I/O
    • Stack size
    • Is this better than Greenlet or Stackless Python?
    • What about python-coev?
    • Can I use uGreen to write Comet apps?
    • Psycopg2 improvements
  • Apache support
    • mod_uwsgi
    • mod_proxy_uwsgi
    • mod_Ruwsgi
  • Cherokee support
    • Dynamic apps
  • Native HTTP support
    • HTTPS support (from 1.3)
    • HTTP sockets
    • The uWSGI HTTP/HTTPS router
    • HTTPS support
    • HTTP Keep-Alive
    • Can I use uWSGI’s HTTP capabilities in production?
  • HTTPS support (from 1.3)
    • Setting SSL/TLS ciphers
    • Client certificate authentication
  • The SPDY router (uWSGI 1.9)
    • Notes
    • TODO
  • Lighttpd support
    • Building the module
    • Configuring Lighttpd
  • Attaching uWSGI to Mongrel2
    • Requirements
    • Configuring Mongrel2
    • Configuring uWSGI for Mongrel2
    • Test them all
    • Async mode
    • Chroot
    • Performance
    • uWSGI clustering + ZeroMQ
    • Mixing standard sockets with ZeroMQ
    • Logging via ZeroMQ
  • Nginx support
    • Building the module (Nginx 0.8.39 and older)
    • Configuring Nginx
    • Clustering
    • Dynamic apps
    • Static files
    • Virtual Hosting
  • Python support
    • The uwsgi Python module
    • uWSGI API - Python decorators
    • Pump support
    • Python Tracebacker
    • Aliasing Python modules
    • Application dictionary
    • Virtualenv support
    • Python 3
    • Paste support
    • Pecan support
    • Using the uwsgi_admin Django app
  • The PyPy plugin
    • Benchmarks for the PyPy plugin
    • Introduction
    • Building libpypy-c (if needed)
    • Install uWSGI with PyPy support
    • The PyPy home
    • The PyPy setup file
    • WSGI support
    • RPC support
    • IPython trick
    • uWSGI API status
    • Options
    • The alternative approach
    • Notes
  • Running PHP scripts in uWSGI
    • Building
    • Running PHP apps with nginx
    • Advanced configuration
    • Run PHP apps without a frontend server
    • uWSGI API support
  • uWSGI Perl support (PSGI)
    • Compiling the PSGI plugin
    • Usage
    • Tested PSGI frameworks/applications
    • Multi-app support
    • The auto reloader (from uWSGI 1.9.18)
    • Notes
    • Real world example, HTML::Mason
  • Ruby support
    • Ruby API support
    • Building uWSGI for Ruby support
    • A note regarding memory consumption
    • A note regarding threads and fibers
    • Running Rack applications on uWSGI
    • Running Ruby on Rails applications on uWSGI
  • Using Lua/WSAPI with uWSGI
    • Building the plugin
    • Why Lua ?
    • Your first WSAPI application
    • Concurrency
    • Abusing coroutines
    • Threading example
    • A note on memory
    • RPC and signals
    • The Lua shell
    • Using Lua as ‘configurator’
    • uWSGI api status
  • JVM in the uWSGI server (updated to 1.9)
    • The JWSGI interface
    • The Clojure/Ring JVM request handler
    • Introduction
    • Building the JVM support
    • Exposing functions via the RPC subsystem
    • Registering signal handlers
    • The fork() problem and multithreading
    • How does it work?
    • Passing options to the JVM
    • Loading classes (without main method)
    • Request handlers
    • Notes
  • The Mono ASP.NET plugin
    • Building uWSGI + Mono
    • Starting the server
    • Concurrency and fork() unfriendliness
    • API access
    • Tricks
  • Running CGI scripts on uWSGI
    • Enabling the plugin
    • Configuring CGI mode
    • Notes
    • Examples
  • The gccgo plugin
    • How it works
    • Why not plain go ?
    • Building the plugin
    • The first app
    • uwsgi.gox
    • Shared libraries VS monolithic binaries
    • Goroutines
    • Options
    • uWSGI API
    • Notes
  • The Symcall plugin
    • Step 1: preparing the environment
    • Step 2: our first request handler:
    • Step 3: building our code as a shared library
    • Final step: map the symcall plugin to the mysym_function symbol
    • Hooks and symcall unleashed: a TCL handler
    • Considerations
  • The XSLT plugin
    • The request handler
    • The routing instruction
  • SSI (Server Side Includes) plugin
    • Using it as a request handler
    • Using SSI as a routing action
    • Supported SSI commands
    • Status
  • uWSGI V8 support
    • Building
    • RPC
    • Signal handlers
    • Multitheading and multiprocess
    • Mules
    • The uWSGI API
    • JSGI 3.0
    • CommonJS
  • The GridFS plugin
    • Requirements and install
    • Standalone quickstart
    • The initial slash problem
    • Multiple mountpoints (and servers)
    • Replica sets
    • Prefixes
    • MIME types and filenames
    • Timeouts
    • MD5 and ETag headers
    • Multithreading
    • Combining with Nginx
    • The ‘gridfs’ internal routing action
    • Notes
  • The GlusterFS plugin
    • Step1: glusterfs installation
    • Step2: the first cluster
    • Step3: uWSGI
    • High availability
    • Multiple mountpoints
    • Multiprocess VS multithread
    • Internal routing
    • Using capabilities (on Linux)
    • Notes:
  • The RADOS plugin
    • Step1: Ceph cluster and content
    • Step2: uWSGI
    • High availability
    • Multiple mountpoints
    • Notes:
  • The Pty plugin
    • Building it
    • Example 1: Rack application shared debugging
    • Example 2: IPython control thread
  • SPNEGO authentication
  • Configuring uWSGI with LDAP
    • Importing the uWSGIConfig schema
    • An example LDIF dump
    • Usage
  • Integrating uWSGI with Erlang
    • Building
    • Activating Erlang support
    • A simple RPC hello world example
    • Python-Erlang mappings
    • Sending messages to Erlang nodes
    • Receiving erlang messages
    • RPC
    • Connection persistence
    • What about Mnesia?
    • Can I run EWGI applications on top of uWSGI?
  • Management Flags
    • myadmin tool
  • uWSGI Go support (1.4 only)
    • Building uWSGI with Go support
    • Writing the first Go application
    • Building your first app
    • Going in production
    • Goroutines (currently Linux/FreeBSD-only)
    • uWSGI api
    • Running from the Emperor
    • Notes
  • uWSGI 2.0.2
    • Bugfixes
    • New features and improvements
  • uWSGI 2.0.1
    • Bugfixes and improvements
    • New features
    • Availability
  • uWSGI 2.0
    • Important changes
    • Bugfixes and improvements
    • New features
    • Availability
  • uWSGI 1.9.21
    • Bugfixes
    • Optimizations
    • New features
    • TODO for 2.0
    • Availability
  • uWSGI 1.9.20
    • First round of deprecations and removals for 2.0
    • Next scheduled deprecations and removals
    • Bugfixes
    • New features
    • Availability
  • uWSGI 1.9.19
    • Bugfixes
    • New features
    • Availability
  • uWSGI 1.9.18
    • License change
    • Bugfixes
    • New Features
    • Availability
  • uWSGI 1.9.17
    • Bugfixes
    • New features
    • Availability
  • uWSGI 1.9.16
    • Important change in the gevent plugin shutdown/reload procedure !!!
    • Bugfixes/Improvements
    • New features
    • Availability
  • uWSGI 1.9.15
    • Bugfixes
    • New features
    • –wait-for-interface
    • Availability
  • uWSGI 1.9.14
    • Bugfixes
    • New features
    • Breaking News !!!
    • Availability
  • uWSGI 1.9.13
    • Bugfixes
    • New features
    • Availability
  • uWSGI 1.9.12
    • Bugfixes
    • New Features
    • Availability
  • uWSGI 1.9.11
    • Bugfixes
    • New features
    • Availability
  • uWSGI 1.9.10
    • Bugfixes
    • New Features
    • Availability
  • uWSGI 1.9.9
    • Special Warning !!!
    • Bugfixes
    • New Features
    • Availability
  • uWSGI 1.9.8
    • Bugfixes
    • Availability
  • uWSGI 1.9.7
    • Bugfixes
    • New features
    • Availability
  • uWSGI 1.9.6
    • Bugfixes
    • New Features
    • Availability
  • uWSGI 1.9.5
    • Bugfixes
    • New features
    • Availability
  • uWSGI 1.9.4
    • Bugfixes
    • New features
    • Availability
  • uWSGI 1.9.3
    • Bugfixes
    • New features
    • Availability
  • uWSGI 1.9.2
    • Bugfixes
    • New features
    • Availability
  • uWSGI 1.9.1
    • Bugfixes
    • The XSLT plugin
    • Legion scrolls api
    • On demand vassals
    • The –exec-post-app hook
    • The pyring build profile
    • The cache router plugin
    • The crypto logger
    • The rpc internal routing instruction
    • Preliminary support for name resolving in the carbon plugin
    • New routing conditions
    • The ‘V’ magic var
    • The ‘mongodb’ generic plugin
    • Build profiles over network
    • Get it
  • uWSGI 1.9
    • Non-blocking for all
    • Coro::AnyEvent
    • The JVM plugin
    • The Mono ASP.NET plugin
    • Language independent HTTP body management
    • Faster uwsgi/HTTP/FastCGI/SCGI native sockets
    • Request logging VS err logging
    • Chain reloading
    • Offloading improvements
    • Better static files management/serving
    • The New Generation Cache subsystem (cache2)
    • The Legion subsystem
    • Cygwin (windows) support
    • Advanced Exceptions subsystem
    • SPDY, SSL and SNI
    • HTTP router keepalive, auto-chunking, auto-gzip and transparent websockets
    • The SSL router (sslrouter)
    • Websockets api
    • New Internal Routing (turing complete ?)
    • Emperor ZMQ plugin
    • Total introspection via the stats server
    • Nagios plugin
    • Removed and deprecated features
    • Working On, Issues and regressions
    • Special thanks
  • uWSGI 1.4.10 (LTS)
    • Bugfixes
    • Availability
 
uWSGI
  • Docs »
  • Edit on GitHub

© Copyright 2013, uWSGI.

Built with Sphinx using a theme provided by Read the Docs.
Read the Docs v: latest
Versions
latest
Downloads
PDF
HTML
Epub
On Read the Docs
Project Home
Builds
Free document hosting provided by Read the Docs.