Developer Guides — Twisted 15.2.1 documentation
Description: An event-driven networking engine written in Python and MIT licensed.

HOME FAQ DOCS DOWNLOAD

### Navigation

- index
- next |
- previous |
- Twisted 15.2.1 documentation »
- Twisted Core »

Go to the latest version of this document.

# Developer Guides

- Introduction

  - Executive summary

    Connecting your software - and having fun too!

- Getting Started

  - Writing a TCP server

    Basic network servers with Twisted.

  - Writing a TCP client

    And basic clients.

  - Test-driven development with Twisted

    Code without tests is broken by definition; Twisted makes it easy to test your network code.

  - Tutorial: Twisted From Scratch

    1. The Evolution of Finger: building a simple finger service
    2. The Evolution of Finger: adding features to the finger service
    3. The Evolution of Finger: cleaning up the finger code
    4. The Evolution of Finger: moving to a component based architecture
    5. The Evolution of Finger: pluggable backends
    6. The Evolution of Finger: a clean web frontend
    7. The Evolution of Finger: Twisted client support using Perspective Broker
    8. The Evolution of Finger: using a single factory for multiple protocols
    9. The Evolution of Finger: a Twisted finger client
    10. The Evolution of Finger: making a finger library
    11. The Evolution of Finger: configuration and packaging of the finger service

  - Setting up the TwistedQuotes application

  - Designing a Twisted application

- Networking and Other Event Sources

  - Twisted Internet

    A brief overview of the `twisted.internet` package.

  - Reactor basics

    The event loop at the core of your program.

  - Using SSL in Twisted

    Add some security to your network transport.

  - UDP Networking

    How to use Twisted’s UDP implementation, including multicast and broadcast functionality.

  - Using processes

    Launching sub-processes, the correct way.

  - Introduction to Deferreds

    Like callback functions, only a lot better.

  - Deferred reference

    In-depth information on Deferreds.

  - Generating deferreds

    More about Deferreds.

  - Scheduling

    Timeouts, repeated events, and more: when you want things to happen later.

  - Using threads

    Running code in threads, and interacting with Twisted in a thread-safe manner.

  - Producers and Consumers: Efficient High-Volume Streaming

    How to pause when buffers fill up.

  - Choosing a reactor and GUI toolkit integration

    GTK+, Windows, epoll() and more: use your GUI of choice, or a faster event loop.

- High-Level Infrastructure

  - Getting Connected with Endpoints

    Create configurable applications that support multiple transports (e.g. TCP and SSL).

  - Interfaces and Adapters (Component Architecture)

    When inheritance isn’t enough.

  - Cred: Pluggable Authentication

    Implementing authentication and authorization that is configurable, pluggable and re-usable.

  - Twisted’s plugin architecture

    A generic plugin system for extendable programs.

- Deploying Twisted Applications

  - Helper programs and scripts (twistd, ..)

    `twistd` lets you daemonize and run your application.

  - Using the Twisted Application Framework

    Writing code that `twistd` can run.

  - Writing Twisted Application Plugins for twistd

    More powerful `twistd` deployment method.

  - Deploying Twisted with systemd

    Use `systemd` to launch and monitor Twisted applications.

- Utilities

  - Emitting and Observing Logs

    Keep a record of what your application is up to, and inspect that record to discover interesting information. (You may also be interested in the legacy logging system if you are maintaining code written to work with older versions of Twisted.)

  - Symbolic constants

    enum-like constants.

  - Twisted RDBMS support with adbapi

    Using SQL with your relational database via DB-API adapters.

  - Parsing command-line arguments

    The command-line argument parsing used by `twistd` .

  - Using Dirdbm: Directory-based Storage

    A simplistic way to store data on your filesystem.

  - Tips for writing tests for Twisted code using Trial

    More information on writing tests.

  - Extremely Low-Level Socket Operations

    Using wrappers for sendmsg(2) and recvmsg(2).

- Asynchronous Messaging Protocol (AMP)

  - Asynchronous Messaging Protocol Overview

    A two-way asynchronous message passing protocol, for when HTTP isn’t good enough.

- Perspective Broker

  - Twisted Spread

    A remote method invocation (RMI) protocol: call methods on remote objects.

  - Introduction to Perspective Broker

  - Using Perspective Broker

  - Managing Clients of Perspectives

  - Passing Complex Types

  - Authentication with Perspective Broker

  - PB Limits

- Positioning

  - Twisted Positioning

- Appendix

  - Porting to Python 3
  - Glossary
  - Tips for debugging with emacs