Skip to content

Latest commit

 

History

History
265 lines (176 loc) · 6.96 KB

index.rst

File metadata and controls

265 lines (176 loc) · 6.96 KB
Raw
LastChangedDate

$LastChangedDate$

LastChangedRevision

$LastChangedRevision$

LastChangedBy

$LastChangedBy$

Developer Guides

vision servers clients trial tutorial/index tutorial/intro tutorial/protocol tutorial/style tutorial/components tutorial/backends tutorial/web tutorial/pb tutorial/factory tutorial/client tutorial/library tutorial/configuration quotes design internet-overview reactor-basics ssl udp process defer-intro defer gendefer time threading producers choosing-reactor endpoints components cred plugin basics application tap systemd logger logging constants rdbms options dirdbm testing sendmsg amp pb pb-intro pb-usage pb-clients pb-copyable pb-cred pb-limits python3 positioning glossary debug-with-emacs

  • Introduction

    • Executive summary <vision>

      Connecting your software - and having fun too!

  • Getting Started

    • Writing a TCP server <servers>

      Basic network servers with Twisted.

    • Writing a TCP client <clients>

      And basic clients.

    • Test-driven development with Twisted <trial>

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

    • Tutorial: Twisted From Scratch <tutorial/index>
      1. The Evolution of Finger: building a simple finger service <tutorial/intro>
      2. The Evolution of Finger: adding features to the finger service <tutorial/protocol>
      3. The Evolution of Finger: cleaning up the finger code <tutorial/style>
      4. The Evolution of Finger: moving to a component based architecture <tutorial/components>
      5. The Evolution of Finger: pluggable backends <tutorial/backends>
      6. The Evolution of Finger: a clean web frontend <tutorial/web>
      7. The Evolution of Finger: Twisted client support using Perspective Broker <tutorial/pb>
      8. The Evolution of Finger: using a single factory for multiple protocols <tutorial/factory>
      9. The Evolution of Finger: a Twisted finger client <tutorial/client>
      10. The Evolution of Finger: making a finger library <tutorial/library>
      11. The Evolution of Finger: configuration and packaging of the finger service <tutorial/configuration>
    • Setting up the TwistedQuotes application <quotes>
    • Designing a Twisted application <design>

  • Networking and Other Event Sources

    • Twisted Internet <internet-overview>

      A brief overview of the twisted.internet package.

    • Reactor basics <reactor-basics>

      The event loop at the core of your program.

    • Using SSL in Twisted <ssl>

      Add some security to your network transport.

    • UDP Networking <udp>

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

    • Using processes <process>

      Launching sub-processes, the correct way.

    • Introduction to Deferreds <defer-intro>

      Like callback functions, only a lot better.

    • Deferred reference <defer>

      In-depth information on Deferreds.

    • Generating deferreds <gendefer>

      More about Deferreds.

    • Scheduling <time>

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

    • Using threads <threading>

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

    • Producers and Consumers: Efficient High-Volume Streaming <producers>

      How to pause when buffers fill up.

    • Choosing a reactor and GUI toolkit integration <choosing-reactor>

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

  • High-Level Infrastructure

    • Getting Connected with Endpoints <endpoints>

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

    • Interfaces and Adapters (Component Architecture) <components>

      When inheritance isn't enough.

    • Cred: Pluggable Authentication <cred>

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

    • Twisted's plugin architecture <plugin>

      A generic plugin system for extendable programs.

  • Deploying Twisted Applications

    • Helper programs and scripts (twistd, ..) <basics>

      twistd lets you daemonize and run your application.

    • Using the Twisted Application Framework <application>

      Writing code that twistd can run.

    • Writing Twisted Application Plugins for twistd <tap>

      More powerful twistd deployment method.

    • Deploying Twisted with systemd <systemd>

      Use systemd to launch and monitor Twisted applications.

  • Utilities

    • Emitting and Observing Logs <logger>

      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 <logging> if you are maintaining code written to work with older versions of Twisted.)

    • Symbolic constants <constants>

      enum-like constants. (Deprecated, spun out into Constantly)

    • Twisted RDBMS support with adbapi <rdbms>

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

    • Parsing command-line arguments <options>

      The command-line argument parsing used by twistd .

    • Using Dirdbm: Directory-based Storage <dirdbm>

      A simplistic way to store data on your filesystem.

    • Tips for writing tests for Twisted code using Trial <testing>

      More information on writing tests.

    • Extremely Low-Level Socket Operations <sendmsg>

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

  • Asynchronous Messaging Protocol (AMP)

    • Asynchronous Messaging Protocol Overview <amp>

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

  • Perspective Broker

    • Twisted Spread <pb>

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

    • Introduction to Perspective Broker <pb-intro>
    • Using Perspective Broker <pb-usage>
    • Managing Clients of Perspectives <pb-clients>
    • Passing Complex Types <pb-copyable>
    • Authentication with Perspective Broker <pb-cred>
    • PB Limits <pb-limits>

  • Positioning

    • Twisted Positioning <positioning>

  • Appendix

    • Porting to Python 3 <python3>
    • Glossary <glossary>
    • Tips for debugging with emacs <debug-with-emacs>