Source code for pyptlib.config
#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
Parts of pyptlib that are useful both to clients and servers.
"""
import os, sys
[docs]class Config(object):
    """
    pyptlib's configuration.
    :var string stateLocation: Location where application should store state.
    :var list managedTransportVer: List of managed-proxy protocol versions that Tor supports.
    :var list transports: Strings of pluggable transport names that Tor wants us to handle.
    :var bool allTransportsEnabled: True if Tor wants us to spawn all the transports.
    :raises: :class:`pyptlib.config.EnvError` if environment was incomplete or corrupted.
    """
    stateLocation = None  # TOR_PT_STATE_LOCATION
    managedTransportVer = []  # TOR_PT_MANAGED_TRANSPORT_VER
    transports = []  # TOR_PT_SERVER_TRANSPORTS or TOR_PT_CLIENT_TRANSPORTS
    allTransportsEnabled = False
    def __init__(self):
        self.stateLocation = self.get('TOR_PT_STATE_LOCATION')
        self.managedTransportVer = self.get('TOR_PT_MANAGED_TRANSPORT_VER').split(',')
[docs]    def checkClientMode(self):
        """
        Check whether Tor wants us to run as a client or as a server.
        :returns: bool -- True if Tor wants us to run as a client.
        """
        return self.check('TOR_PT_CLIENT_TRANSPORTS')
 
[docs]    def getStateLocation(self):
        """
        :returns: string -- The state location.
        """
        return self.stateLocation
 
[docs]    def getManagedTransportVersions(self):
        """
        :returns: list -- The managed-proxy protocol versions that Tor supports.
        """
        return self.managedTransportVer
 
[docs]    def checkManagedTransportVersion(self, version):
        """
        Check if Tor supports a specific managed-proxy protocol version.
        :param string version: A managed-proxy protocol version.
        :returns: bool -- True if version is supported.
        """
        return version in self.managedTransportVer
 
[docs]    def getAllTransportsEnabled(self):
        """
        Check if Tor wants the application to spawn all its transpotrs.
        :returns: bool -- True if Tor wants the application to spawn all its transports.
        """
        return self.allTransportsEnabled
 
[docs]    def checkTransportEnabled(self, transport):
        """
        Check if Tor wants the application to spawn a specific transport.
        :param string transport: The name of a pluggable transport.
        :returns: bool -- True if Tor wants the application to spawn that transport.
        """
        return self.allTransportsEnabled or transport in self.transports
 
[docs]    def writeEnvError(self, message):  # ENV-ERROR
        """
        Announce that an error occured while parsing the environment.
        :param str message: Error message.
        """
        self.emit('ENV-ERROR %s' % message)
 
[docs]    def writeVersion(self, version):  # VERSION
        """
        Announce that a specific managed-proxy protocol version is supported.
        :param str version: A managed-proxy protocol version.
        """
        self.emit('VERSION %s' % version)
 
[docs]    def writeVersionError(self):  # VERSION-ERROR
        """
        Announce that we could not find a supported managed-proxy
        protocol version.
        """
        self.emit('VERSION-ERROR no-version')
 
[docs]    def check(self, key):
        """
        Check the environment for a specific environment variable.
        :param str key: Environment variable key.
        :returns: bool -- True if the environment variable is set.
        """
        return key in os.environ
 
[docs]    def get(self, key):
        """
        Get the value of an environment variable.
        :param str key: Environment variable key.
        :returns: str -- The value of the envrionment variable.
        :raises: :class:`pyptlib.config.EnvError` if environment
        variable could not be found.
        """
        if key in os.environ:
            return os.environ[key]
        else:
            message = 'Missing environment variable %s' % key
            self.writeEnvError(message)
            raise EnvError(message)
 
[docs]    def emit(self, msg):
        """
        Announce a message.
        :param str msg: A message.
        """
        print msg
        sys.stdout.flush()
  
[docs]class EnvError(Exception):
    """
    Thrown when the environment is incomplete or corrupted.
    """
    pass