def _startTLS(self):
self.TLS = 1
klass = self.__class__
class TLSConnection(_TLSMixin, klass):
implements(interfaces.ISSLTransport)
components.backwardsCompatImplements(TLSConnection)
self.__class__ = TLSConnection
def _getTLSClass(klass, _existing={}):
if klass not in _existing:
class TLSConnection(_TLSMixin, klass):
implements(interfaces.ISSLTransport)
components.backwardsCompatImplements(TLSConnection)
_existing[klass] = TLSConnection
return _existing[klass]
def _getTLSClass(klass, _existing={}):
if klass not in _existing:
class TLSConnection(_TLSMixin, klass):
implements(interfaces.ISSLTransport)
components.backwardsCompatImplements(TLSConnection)
_existing[klass] = TLSConnection
return _existing[klass]
def testClassIsGCd(self):
import weakref, gc
class Test(object):
zinterface.implements(IZope)
# Do some stuff with it
components.backwardsCompatImplements(Test)
IZope(Test())
# Make a weakref to it, then ensure the weakref goes away
r = weakref.ref(Test)
del Test
gc.collect()
self.assertEquals(r(), None)
def removeAll(self):
return self._removeAll(reads, writes)
where reads, writes are iterables.
"""
readers = [reader for reader in readers if
reader is not self.waker]
readers_dict = {}
for reader in readers:
readers_dict[reader] = 1
for reader in readers:
self.removeReader(reader)
self.removeWriter(reader)
writers = [writer for writer in writers if
writer not in readers_dict]
for writer in writers:
self.removeWriter(writer)
return readers+writers
if sslEnabled:
classImplements(PosixReactorBase, IReactorSSL)
if unixEnabled:
classImplements(PosixReactorBase, IReactorUNIX, IReactorUNIXDatagram, IReactorProcess)
components.backwardsCompatImplements(PosixReactorBase)
__all__ = ["PosixReactorBase"]
def registerProducer(self, producer, streaming):
self.producer = producer
self.producerIsStreaming = streaming
def unregisterProducer(self):
if self.producer is not None:
del self.producer
del self.producerIsStreaming
if self.consumer:
self.consumer.unregisterProducer()
def __repr__(self):
return '<%s@%x around %s>' % (self.__class__, id(self), self.consumer)
components.backwardsCompatImplements(BasicProducerConsumerProxy)
class ProducerConsumerProxy(BasicProducerConsumerProxy):
"""ProducerConsumerProxy with a finite buffer.
When my buffer fills up, I have my parent Producer pause until my buffer
has room in it again.
"""
# Copies much from abstract.FileDescriptor
bufferSize = 2**2**2**2
producerPaused = False
unregistered = False
def pauseProducing(self):
for text in self.inputCache:
self.pushThroughInputConduit(text)
self.inputCache = []
print "DONE HOOKING", self.inputCache
def pushThroughInputConduit(self, inp):
"""Push some text through the input conduit.
"""
print "PUSHING INPUT", inp
if self.input is None:
self.inputCache.append(inp)
else:
self.input(inp)
components.backwardsCompatImplements(WovenLivePage)
class Stack:
def __init__(self, stack=None):
if stack is None:
self.stack = []
else:
self.stack = stack
def push(self, item):
self.stack.insert(0, item)
def pop(self):
if self.stack:
return self.stack.pop(0)
def registerProducer(self, producer, streaming):
self.producer = producer
self.producerIsStreaming = streaming
def unregisterProducer(self):
if self.producer is not None:
del self.producer
del self.producerIsStreaming
if self.consumer:
self.consumer.unregisterProducer()
def __repr__(self):
return '<%s@%x around %s>' % (self.__class__, id(self), self.consumer)
components.backwardsCompatImplements(BasicProducerConsumerProxy)
class ProducerConsumerProxy(BasicProducerConsumerProxy):
"""ProducerConsumerProxy with a finite buffer.
When my buffer fills up, I have my parent Producer pause until my buffer
has room in it again.
"""
# Copies much from abstract.FileDescriptor
bufferSize = 2**2**2**2
producerPaused = False
unregistered = False
def pauseProducing(self):
def getTcpNoDelay(self):
return operator.truth(self.socket.getsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY))
def setTcpNoDelay(self, enabled):
self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, enabled)
def getTcpKeepAlive(self):
return operator.truth(self.socket.getsockopt(socket.SOL_SOCKET,
socket.SO_KEEPALIVE))
def setTcpKeepAlive(self, enabled):
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, enabled)
if SSL:
classImplements(Connection, interfaces.ITLSTransport)
components.backwardsCompatImplements(Connection)
class BaseClient(Connection):
"""A base class for client TCP (and similiar) sockets.
"""
addressFamily = socket.AF_INET
socketType = socket.SOCK_STREAM
def _finishInit(self, whenDone, skt, error, reactor):
"""Called by base classes to continue to next stage of initialization."""
if whenDone:
Connection.__init__(self, skt, None, reactor)
self.doWrite = self.doConnect
self.doRead = self.doConnect
reactor.callLater(0, whenDone)
self.services = {}
def getServiceNamed(self, serviceName):
"""Retrieve the named service from this application.
Raise a KeyError if there is no such service name.
"""
return self.services[serviceName]
def addService(self, service):
"""Add a service to this collection.
"""
if self.services.has_key(service.serviceName):
self.removeService(service)
self.services[service.serviceName] = service
def removeService(self, service):
"""Remove a service from this collection."""
del self.services[service.serviceName]
components.backwardsCompatImplements(_AbstractServiceCollection)
class ApplicationService(Accessor, styles.Versioned):
"""I am a service you can add to an application.
I represent some chunk of functionality which may be bound to many or no
event sources. By adding an ApplicationService to an L{Application}, it
will be notified when the Application starts and stops (or removes/shuts
down the service). See the L{startService} and L{stopService} calls.
Since services may want to incorporate certain other elements,
notably Perspective Broker (remote invocation) accessibility
and authentication, derivatives of ApplicationService exist
in L{twisted.cred.service<twisted.cred.service.Service>} and
L{twisted.spread.pb<twisted.spread.pb.Service>}. These may be more
suitable for your service than directly subclassing ApplicationService.
"""
serviceType = None
serviceName = None
t = time.time()
self.challenge = '<%d.%d@%s>' % (r, t, self.host)
return self.challenge
def setResponse(self, response):
self.username, self.response = response.split(None, 1)
def moreChallenges(self):
return False
def checkPassword(self, password):
verify = hmac.HMAC(password, self.challenge).hexdigest()
return verify == self.response
components.backwardsCompatImplements(CramMD5Credentials)
class UsernameHashedPassword:
interface.implements(IUsernameHashedPassword)
def __init__(self, username, hashed):
self.username = username
self.hashed = hashed
def checkPassword(self, password):
return self.hashed == password
components.backwardsCompatImplements(UsernameHashedPassword)
def simulate(self):
"""Run simulation loops and reschedule callbacks.
"""
global _simtag
if _simtag is not None:
gobject.source_remove(_simtag)
self.runUntilCurrent()
timeout = min(self.timeout(), 0.1)
if timeout is None:
timeout = 0.1
# grumble
_simtag = gobject.timeout_add(int(timeout * 1010), self.simulate)
components.backwardsCompatImplements(Gtk2Reactor)
class PortableGtkReactor(selectreactor.SelectReactor):
"""Reactor that works on Windows.
input_add is not supported on GTK+ for Win32, apparently.
"""
def crash(self):
import gtk
# mainquit is deprecated in newer versions
if hasattr(gtk, 'main_quit'):
gtk.main_quit()
else:
gtk.mainquit()
def loadApplication(filename, kind, passphrase=None):
"""Load Application from file
@type filename: C{str}
@type kind: C{str}
@type passphrase: C{str}
Load application from a given file. The serialization format it
was saved in should be given as C{kind}, and is one of 'pickle', 'source',
'xml' or 'python'. If C{passphrase} is given, the application was encrypted
with the given passphrase.
"""
if kind == 'python':
application = sob.loadValueFromFile(filename, 'application', passphrase)
else:
application = sob.load(filename, kind, passphrase)
if IService(application, None) is None:
from twisted.application import compat
application = compat.convert(application)
return application
# add backwards compatible __implements__ attribute
components.backwardsCompatImplements(Service)
components.backwardsCompatImplements(MultiService)
components.backwardsCompatImplements(Process)
__all__ = ['IService', 'Service', 'IServiceCollection', 'MultiService',
'IProcess', 'Process', 'Application', 'loadApplication']
request.write(
"<html><head><title>%s: %s</title></head><body>\n" %
(html.escape(str(
failure.type)), html.escape(str(failure.value))))
else:
request.write(
"<html><head><title>Failure!</title></head><body>\n")
utils.renderFailure(failure, request)
request.write("<h3>Here is the partially processed DOM:</h3>")
request.write("\n<pre>\n")
request.write(html.escape(xml))
request.write("\n</pre>\n")
request.write("</body></html>")
request.finish()
return failure
components.backwardsCompatImplements(View)
class LiveView(View):
livePage = 1
def wvfactory_webConduitGlue(self, request, node, m):
if request.getHeader("user-agent").count("MSIE"):
return View(m, templateFile="FlashConduitGlue.html")
else:
return View(m, templateFile="WebConduitGlue.html")
def wvupdate_woven_flashConduitSessionView(self, request, wid, mod):
#print "updating flash thingie"
uid = request.getSession().uid
n = wid.templateNode
self.protocol.doStop()
self.connected = 0
self.socket.close()
del self.socket
del self.fileno
if hasattr(self, "d"):
self.d.callback(None)
del self.d
def setLogStr(self):
self.logstr = reflect.qual(self.protocol.__class__) + " (UDP)"
def getHost(self):
return address.UNIXAddress(self.socket.getsockname())
components.backwardsCompatImplements(DatagramPort)
class ConnectedDatagramPort(DatagramPort):
"""A connected datagram UNIX socket."""
implementsOnly(interfaces.IUNIXDatagramConnectedTransport,
*(implementedBy(base.BasePort)))
def __init__(self, addr, proto, maxPacketSize=8192, mode=0666, bindAddress=None, reactor=None):
assert isinstance(proto, protocol.ConnectedDatagramProtocol)
DatagramPort.__init__(self, bindAddress, proto, maxPacketSize, mode, reactor)
self.remoteaddr = addr
def startListening(self):
try:
"""
pass
def domChanged(self, request, widget, node):
parent = getattr(self, '_parent', None)
if parent is not None:
parent.domChanged(request, widget, node)
def pageRenderComplete(self, request):
"""Override this to recieve notification when the view rendering
process is complete.
"""
pass
components.backwardsCompatImplements(Controller)
WOVEN_PATH = os.path.split(woven.__file__)[0]
class LiveController(Controller):
"""A Controller that encapsulates logic that makes it possible for this
page to be "Live". A live page can have it's content updated after the
page has been sent to the browser, and can translate client-side
javascript events into server-side events.
"""
pageSession = None
def render(self, request):
"""First, check to see if this request is attempting to hook up the
output conduit. If so, do it. Otherwise, unlink the current session's
def spawnProcess(self,
processProtocol,
executable,
args=(),
env={},
path=None,
uid=None,
gid=None,
usePTY=0):
"""Spawn a process."""
if uid is not None:
raise ValueError("Setting UID is unsupported on this platform.")
if gid is not None:
raise ValueError("Setting GID is unsupported on this platform.")
if usePTY:
raise ValueError("PTYs are unsupported on this platform.")
return Process(self, processProtocol, executable, args, env, path)
components.backwardsCompatImplements(Win32Reactor)
def install():
threadable.init(1)
r = Win32Reactor()
import main
main.installReactor(r)
__all__ = ["Win32Reactor", "install"]
from twisted.plugin import IPlugin
class _Reporter(object):
implements(IPlugin, IReporter)
def __init__(self, name, module, description, longOpt, shortOpt, klass):
self.name = name
self.module = module
self.description = description
self.longOpt = longOpt
self.shortOpt = shortOpt
self.klass = klass
backwardsCompatImplements(_Reporter)
Tree = _Reporter("Tree Reporter",
"twisted.trial.reporter",
description="verbose color output (default reporter)",
longOpt="verbose",
shortOpt="v",
klass="TreeReporter")
BlackAndWhite = _Reporter("Black-And-White Reporter",
"twisted.trial.reporter",
description="Colorless verbose output",
longOpt="bwverbose",
shortOpt="o",
klass="VerboseTextReporter")
"""
def generate(self, request, node):
"""The generate method should do the work of mutating the DOM
based on the object this adapter wraps.
"""
pass
class NodeMutator:
implements(INodeMutator)
def __init__(self, data):
self.data = data
components.backwardsCompatImplements(NodeMutator)
class NodeNodeMutator(NodeMutator):
"""A NodeNodeMutator replaces the node that is passed in to generate
with the node it adapts.
"""
def __init__(self, data):
assert data is not None
NodeMutator.__init__(self, data)
def generate(self, request, node):
if self.data is not node:
parent = node.parentNode
if parent:
parent.replaceChild(self.data, node)
"""Log pickles to DirDBM directory."""
implements(base.ICommandLog)
def __init__(self, logPath):
self.db = dirdbm.Shelf(logPath)
indexs = map(int, self.db.keys())
if indexs:
self.currentIndex = max(indexs)
else:
self.currentIndex = 0
def logCommand(self, command, time):
"""Log a command."""
self.currentIndex += 1
self.db[str(self.currentIndex)] = (time, command)
return defer.succeed(1)
def getCurrentIndex(self):
"""Return index of last command logged."""
return self.currentIndex
def getCommandsSince(self, index):
result = []
for i in range(index, self.currentIndex + 1):
result.append(self.db[str(i)])
return result
backwardsCompatImplements(DirDBMLog)
will be the rendered page, unless the return value is
twisted.web.server.NOT_DONE_YET, in which case it is this
class's responsibility to write the results to
request.write(data), then call request.finish().
Old code that overrides render() directly is likewise expected
to return a string or NOT_DONE_YET.
"""
m = getattr(self, 'render_' + request.method, None)
if not m:
from twisted.web.server import UnsupportedMethod
raise UnsupportedMethod(getattr(self, 'allowedMethods', ()))
return m(request)
def render_HEAD(self, request):
"""Default handling of HEAD method.
I just return self.render_GET(request). When method is HEAD,
the framework will handle this correctly.
"""
return self.render_GET(request)
components.backwardsCompatImplements(Resource)
#t.w imports
#This is ugly, I know, but since error.py directly access resource.Resource
#during import-time (it subclasses it), the Resource class must be defined
#by the time error is imported.
import error
"""
from twisted.persisted import dirdbm
from twisted.internet import defer
from twisted.python.components import backwardsCompatImplements
from zope.interface import implements
import base
class DirDBMLog:
"""Log pickles to DirDBM directory."""
implements(base.ICommandLog)
def __init__(self, logPath):
self.db = dirdbm.Shelf(logPath)
indexs = map(int, self.db.keys())
if indexs:
self.currentIndex = max(indexs)
else:
self.currentIndex = 0
def logCommand(self, command, time):
"""Log a command."""
self.currentIndex += 1
self.db[str(self.currentIndex)] = (time, command)
return defer.succeed(1)
def getCurrentIndex(self):
"""Return index of last command logged."""
return self.currentIndex
def getCommandsSince(self, index):
result = []
for i in range(index, self.currentIndex + 1):
result.append(self.db[str(i)])
return result
backwardsCompatImplements(DirDBMLog)
self.cachedFor = id(request)
self.dataWillChange()
self.orig = self.original = self._getter(request)
return self.original
def setData(self, request, data):
if self._setter is not None:
self.cachedFor = None
return self._setter(request, data)
else:
if hasattr(self, 'parent') and self.parent:
self.parent.setSubmodel(request, self.name, data)
self.orig = self.original = data
components.backwardsCompatImplements(Model)
class MethodModel(Model):
"""Look up submodels with wmfactory_* methods.
"""
def submodelCheck(self, request, name):
"""Allow any submodel for which I have a submodel.
"""
return hasattr(self, "wmfactory_" + name)
def submodelFactory(self, request, name):
"""Call a wmfactory_name method on this model.
"""
meth = getattr(self, "wmfactory_" + name)
return meth(request)
if self.kw:
L.append(", ".join([
'%s=%s' % (k, reflect.safe_repr(v))
for (k, v) in self.kw.iteritems()
]))
L.append(")")
if self.debug:
L.append("\n\ntraceback at creation: \n\n%s" %
(' '.join(self.creator)))
L.append('>')
return "".join(L)
components.backwardsCompatImplements(DelayedCall)
class ThreadedResolver:
implements(IResolverSimple)
def __init__(self, reactor):
self.reactor = reactor
self._runningQueries = {}
def _fail(self, name, err):
err = error.DNSLookupError("address %r not found: %s" % (name, err))
return failure.Failure(err)
def _cleanup(self, name, lookupDeferred):
userDeferred, cancelCall = self._runningQueries[lookupDeferred]
return perspective
def remote_console(self, messages):
for kind, content in messages:
if isinstance(content, types.StringTypes):
self.original.output.append(content, kind)
elif (kind == "exception") and isinstance(content,
failure.Failure):
content.printTraceback(
_Notafile(self.original.output, "exception"))
else:
self.original.output.append(str(content), kind)
def remote_receiveExplorer(self, xplorer):
pass
def remote_listCapabilities(self):
return self.capabilities
def _cbDisconnected(self, perspective):
self.perspective = None
def do(self, text):
if self.perspective is None:
raise OfflineError
return self.perspective.callRemote("do", text)
components.backwardsCompatImplements(ManholeClient)
components.registerAdapter(ManholeClient, ManholeWindow, IManholeClient)
will be the rendered page, unless the return value is
twisted.web.server.NOT_DONE_YET, in which case it is this
class's responsibility to write the results to
request.write(data), then call request.finish().
Old code that overrides render() directly is likewise expected
to return a string or NOT_DONE_YET.
"""
m = getattr(self, 'render_' + request.method, None)
if not m:
from twisted.web.server import UnsupportedMethod
raise UnsupportedMethod(getattr(self, 'allowedMethods', ()))
return m(request)
def render_HEAD(self, request):
"""Default handling of HEAD method.
I just return self.render_GET(request). When method is HEAD,
the framework will handle this correctly.
"""
return self.render_GET(request)
components.backwardsCompatImplements(Resource)
#t.w imports
#This is ugly, I know, but since error.py directly access resource.Resource
#during import-time (it subclasses it), the Resource class must be defined
#by the time error is imported.
import error
self.host = host
def getChallenge(self):
if self.challenge:
return self.challenge
r = random.randrange(0x7fffffff)
t = time.time()
self.challenge = '<%d.%d@%s>' % (r, t, self.host)
return self.challenge
def setResponse(self, response):
self.username, self.response = response.split(None, 1)
def moreChallenges(self):
return False
def checkPassword(self, password):
verify = hmac.HMAC(password, self.challenge).hexdigest()
return verify == self.response
components.backwardsCompatImplements(CramMD5Credentials)
class UsernameHashedPassword:
interface.implements(IUsernameHashedPassword)
def __init__(self, username, hashed):
self.username = username
self.hashed = hashed
def checkPassword(self, password):
return self.hashed == password
components.backwardsCompatImplements(UsernameHashedPassword)
class UsernamePassword:
interface.implements(IUsernamePassword)
def __init__(self, username, password):
self.username = username
self.password = password
def checkPassword(self, password):
return self.password == password
STOP_RENDERING = 1
RESTART_RENDERING = 2
class INodeMutator(components.Interface):
"""A component that implements NodeMutator knows how to mutate
DOM based on the instructions in the object it wraps.
"""
def generate(self, request, node):
"""The generate method should do the work of mutating the DOM
based on the object this adapter wraps.
"""
pass
class NodeMutator:
implements(INodeMutator)
def __init__(self, data):
self.data = data
components.backwardsCompatImplements(NodeMutator)
class NodeNodeMutator(NodeMutator):
"""A NodeNodeMutator replaces the node that is passed in to generate
with the node it adapts.
"""
def __init__(self, data):
assert data is not None
NodeMutator.__init__(self, data)
def generate(self, request, node):
if self.data is not node:
parent = node.parentNode
if parent:
parent.replaceChild(self.data, node)
else:
log.msg("Warning: There was no parent for node %s; node not mutated." % node)
return self.data
Unless I'm overridden, everything gets the same bucket.
@returns: something to be used as a key in the bucket cache.
"""
return None
def sweep(self):
"""I throw away references to empty buckets."""
for key, bucket in self.buckets.items():
if (bucket._refcount == 0) and bucket.drip():
del self.buckets[key]
self.lastSweep = time()
backwardsCompatImplements(HierarchicalBucketFilter)
class FilterByHost(HierarchicalBucketFilter):
"""A bucket filter with a bucket for each host.
"""
sweepInterval = 60 * 20
def getBucketKey(self, transport):
return transport.getPeer()[1]
class FilterByServer(HierarchicalBucketFilter):
"""A bucket filter with a bucket for each service.
"""
sweepInterval = None
log.deferr()
if closed:
self._disconnectSelectable(fd, closed, action == "doRead")
doIteration = doWaitForMultipleEvents
def spawnProcess(self, processProtocol, executable, args=(), env={}, path=None, uid=None, gid=None, usePTY=0):
"""Spawn a process."""
if uid is not None:
raise ValueError("Setting UID is unsupported on this platform.")
if gid is not None:
raise ValueError("Setting GID is unsupported on this platform.")
if usePTY:
raise ValueError("PTYs are unsupported on this platform.")
return Process(self, processProtocol, executable, args, env, path)
components.backwardsCompatImplements(Win32Reactor)
def install():
threadable.init(1)
r = Win32Reactor()
import main
main.installReactor(r)
__all__ = ["Win32Reactor", "install"]
x = self
while x.parent is not None:
L.append(x.offset)
x = x.parent
L.reverse()
return L
def __getitem__(self, index):
slot, o = self.get(index)
n = INode(o, persist=False)
n.postInit(index, self, slot)
return n
def origstr(self):
return str(self.original)
def format(self):
return (self.slot, self.origstr())
components.backwardsCompatImplements(InspectorNode)
class ConstantNode(InspectorNode):
def __len__(self):
return 0
class DictionaryNode(InspectorNode):
def get(self, index):
L = self.original.items()
L.sort()
return L[index]
def __len__(self):
return len(self.original)
def origstr(self):
return "Dictionary"
class ListNode(InspectorNode):
def get(self, index):
return index, self.original[index]
self.service = service
self._cache = {}
def requestAvatar(self, avatarId, mind, *interfaces):
if pb.IPerspective not in interfaces:
raise NotImplementedError("no interface")
if avatarId in self._cache:
p = self._cache[avatarId]
else:
p = Perspective(self.service)
p.attached(mind, avatarId)
def detached():
p.detached(mind, avatarId)
return (pb.IPerspective, p, detached)
components.backwardsCompatImplements(Realm)
class Service(service.Service):
welcomeMessage = (
"\nHello %(you)s, welcome to Manhole "
"on %(host)s.\n"
"%(longversion)s.\n\n")
def __init__(self, unsafeTracebacks=False, namespace=None):
self.unsafeTracebacks = unsafeTracebacks
self.namespace = {
'__name__': '__manhole%x__' % (id(self),),
'sys': sys
}
def getHost(self):
"""Returns the address from which I am connecting."""
h, p = self.socket.getsockname()
return address.IPv4Address("TCP", h, p, "SSL")
def getPeer(self):
"""Returns the address that I am connected."""
return address.IPv4Address("TCP", self.addr[0], self.addr[1], "SSL")
def _connectDone(self):
self.startTLS(self.ctxFactory)
self.startWriting()
tcp.Client._connectDone(self)
components.backwardsCompatImplements(Client)
class Server(tcp.Server):
"""I am an SSL server.
"""
implements(interfaces.ISSLTransport)
def getHost(self):
"""Return server's address."""
h, p = self.socket.getsockname()
return address.IPv4Address("TCP", h, p, "SSL")
def getPeer(self):
"""Return address of peer."""
self.service = service
self._cache = {}
def requestAvatar(self, avatarId, mind, *interfaces):
if pb.IPerspective not in interfaces:
raise NotImplementedError("no interface")
if avatarId in self._cache:
p = self._cache[avatarId]
else:
p = Perspective(self.service)
p.attached(mind, avatarId)
def detached():
p.detached(mind, avatarId)
return (pb.IPerspective, p, detached)
components.backwardsCompatImplements(Realm)
class Service(service.Service):
welcomeMessage = (
"\nHello %(you)s, welcome to Manhole "
"on %(host)s.\n"
"%(longversion)s.\n\n")
def __init__(self, unsafeTracebacks=False, namespace=None):
self.unsafeTracebacks = unsafeTracebacks
self.namespace = {
'__name__': '__manhole%x__' % (id(self),),
'sys': sys
}
for i in range(3):
try:
creds = (response + ('=' * i)).decode('base64')
except:
pass
else:
break
else:
# Totally bogus
raise SIPError(400)
p = creds.split(':', 1)
if len(p) == 2:
return cred.credentials.UsernamePassword(*p)
raise SIPError(400)
components.backwardsCompatImplements(BasicAuthorizer)
class DigestedCredentials(cred.credentials.UsernameHashedPassword):
"""Yet Another Simple Digest-MD5 authentication scheme"""
def __init__(self, username, fields, challenges):
self.username = username
self.fields = fields
self.challenges = challenges
def checkPassword(self, password):
method = 'REGISTER'
response = self.fields.get('response')
uri = self.fields.get('uri')
nonce = self.fields.get('nonce')
def logPrefix(self):
"""Returns the name of my class, to prefix log entries with.
"""
return self.logstr
def getHost(self):
"""
Returns an IPv4Address.
This indicates the address from which I am connecting.
"""
return address.IPv4Address(
'UDP', *(self.socket.getsockname() + ('INET_UDP', )))
components.backwardsCompatImplements(Port)
class ConnectedPort(Port):
"""DEPRECATED.
A connected UDP socket."""
implements(interfaces.IUDPConnectedTransport)
def __init__(self,
(remotehost, remoteport),
port,
proto,
interface='',
maxPacketSize=8192,
a = 3
self.assertEquals(IFoo.a, 3)
from zope import interface as zinterface
class IZope(zinterface.Interface):
def amethod(a, b):
pass
class Zopeable:
pass
class Zoper:
zinterface.implements(IZope, IAdder)
components.backwardsCompatImplements(Zoper) # add __implements__
components.registerAdapter(lambda o: id(o), Zopeable, IZope)
class SubZoper(Zoper):
zinterface.implements(ISub)
class OldStyle:
__implements__ = IAdder
class NewSubOfOldStyle(OldStyle):
zinterface.implements(IZope)
components.backwardsCompatImplements(NewSubOfOldStyle)
class TestZope(unittest.TestCase):
def getChild(self, name, request):
# Don't call the rememberURL if we already did once; That way
# we can support an idiom of setting appName as a class
# attribue *even if* the same class is used more than once in
# a hierarchy of Pages.
if self.appRoot and not request.getRootURL():
request.rememberRootURL()
return controller.Controller.getChild(self, name, request)
def renderView(self, request):
return view.View.render(self,
request,
doneCallback=self.gatheredControllers)
components.backwardsCompatImplements(Page)
class LivePage(model.MethodModel, controller.LiveController, view.LiveView):
appRoot = False
def __init__(self,
m=None,
templateFile=None,
inputhandlers=None,
templateDirectory=None,
controllers=None,
*args,
**kwargs):
template = kwargs.setdefault('template', None)
isLeaf = False
def __init__(self, resource, name):
self.authenticated = Authenticated(name)
self.resource = resource
def render(self, request):
request.setComponent(Authenticated, self.authenticated)
return self.resource.render(request)
def getChildWithDefault(self, path, request):
request.setComponent(Authenticated, self.authenticated)
return self.resource.getChildWithDefault(path, request)
components.backwardsCompatImplements(MarkAuthenticatedResource)
class MarkingRealm:
implements(portal.IRealm)
def __init__(self, resource, nonauthenticated=None):
self.resource = resource
self.nonauthenticated = (nonauthenticated
or MarkAuthenticatedResource(resource, None))
def requestAvatar(self, avatarId, mind, *interfaces):
if resource.IResource not in interfaces:
raise NotImplementedError("no interface")
if avatarId:
"""
return self.getPerspectiveRequest(name)
def getPerspectiveRequest(self, name):
"""Return a Deferred which is a request for a perspective on this service.
"""
try:
p = self.getPerspectiveNamed(name)
except KeyError:
return self.loadPerspective(name)
else:
return defer.succeed(p)
def getServiceName(self):
"""The name of this service.
"""
return self.serviceName or self.getServiceType()
def getServiceType(self):
"""Get a string describing the type of this service.
"""
return self.serviceType or reflect.qual(self.__class__)
def setServiceParent(self, parent):
app.ApplicationService.setServiceParent(self, parent)
if self.authorizer is not None:
self.authorizer.setServiceCollection(parent)
components.backwardsCompatImplements(Service)
self.perspective = perspective
perspective.notifyOnDisconnect(self._cbDisconnected)
return perspective
def remote_console(self, messages):
for kind, content in messages:
if isinstance(content, types.StringTypes):
self.original.output.append(content, kind)
elif (kind == "exception") and isinstance(content, failure.Failure):
content.printTraceback(_Notafile(self.original.output,
"exception"))
else:
self.original.output.append(str(content), kind)
def remote_receiveExplorer(self, xplorer):
pass
def remote_listCapabilities(self):
return self.capabilities
def _cbDisconnected(self, perspective):
self.perspective = None
def do(self, text):
if self.perspective is None:
raise OfflineError
return self.perspective.callRemote("do", text)
components.backwardsCompatImplements(ManholeClient)
components.registerAdapter(ManholeClient, ManholeWindow, IManholeClient)
def pauseProducing(self):
self.stopReading()
def stopProducing(self):
self.loseConnection()
def fileno(self):
"""File Descriptor number for select().
This method must be overridden or assigned in subclasses to
indicate a valid file descriptor for the operating system.
"""
return -1
components.backwardsCompatImplements(FileDescriptor)
def isIPAddress(addr):
parts = string.split(addr, '.')
if len(parts) == 4:
try:
for part in map(int, parts):
if not (0 <= part < 256):
break
else:
return 1
except ValueError:
pass
return 0
getPerspectiveRequest provides management of caching perspectives.
@returntype: Deferred Perspective
"""
return defer.fail("No such perspective %s" % name)
def getPerspectiveForIdentity(self, name, identity):
"""A hook to use if the identity is required when getting the perspective.
"""
return self.getPerspectiveRequest(name)
def getPerspectiveRequest(self, name):
"""Return a Deferred which is a request for a perspective on this service.
"""
try:
p = self.getPerspectiveNamed(name)
except KeyError:
return self.loadPerspective(name)
else:
return defer.succeed(p)
def getServiceName(self):
"""The name of this service.
"""
return self.serviceName or self.getServiceType()
def getServiceType(self):
"""Get a string describing the type of this service.
"""
return self.serviceType or reflect.qual(self.__class__)
def setServiceParent(self, parent):
app.ApplicationService.setServiceParent(self, parent)
if self.authorizer is not None:
self.authorizer.setServiceCollection(parent)
components.backwardsCompatImplements(Service)
from twisted.python.components import backwardsCompatImplements
from twisted.plugin import IPlugin, ITestPlugin, ITestPlugin2
class TestPlugin:
"""A plugin used solely for testing purposes.
"""
classProvides(ITestPlugin, IPlugin)
def test1():
pass
test1 = staticmethod(test1)
backwardsCompatImplements(TestPlugin)
class AnotherTestPlugin:
"""Another plugin used solely for testing purposes.
"""
classProvides(ITestPlugin2, IPlugin)
def test():
pass
test = staticmethod(test)
backwardsCompatImplements(AnotherTestPlugin)
self.socket.getsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY))
def setTcpNoDelay(self, enabled):
self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, enabled)
def getTcpKeepAlive(self):
return operator.truth(
self.socket.getsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE))
def setTcpKeepAlive(self, enabled):
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, enabled)
if SSL:
classImplements(Connection, interfaces.ITLSTransport)
components.backwardsCompatImplements(Connection)
class BaseClient(Connection):
"""A base class for client TCP (and similiar) sockets.
"""
addressFamily = socket.AF_INET
socketType = socket.SOCK_STREAM
def _finishInit(self, whenDone, skt, error, reactor):
"""Called by base classes to continue to next stage of initialization."""
if whenDone:
Connection.__init__(self, skt, None, reactor)
self.doWrite = self.doConnect
self.doRead = self.doConnect
reactor.callLater(0, whenDone)
"""
I'm a test drop-in. The plugin system's unit tests use me. No one
else should.
"""
from zope.interface import classProvides
from twisted.python.components import backwardsCompatImplements
from twisted.plugin import IPlugin, ITestPlugin, ITestPlugin2
class TestPlugin:
"""A plugin used solely for testing purposes.
"""
classProvides(ITestPlugin,
IPlugin)
def test1():
pass
test1 = staticmethod(test1)
backwardsCompatImplements(TestPlugin)
class AnotherTestPlugin:
"""Another plugin used solely for testing purposes.
"""
classProvides(ITestPlugin2,
IPlugin)
def test():
pass
test = staticmethod(test)
backwardsCompatImplements(AnotherTestPlugin)
class ThirdTestPlugin:
"""Another plugin used solely for testing purposes.
"""
classProvides(ITestPlugin2,
IPlugin)
def test():
"""
ext, dumpFunc = self._getStyle()
if passphrase:
ext = 'e' + ext
finalname, filename = self._getFilename(filename, ext, tag)
log.msg("Saving " + self.name + " application to " + finalname + "...")
self._saveTemp(filename, passphrase, dumpFunc)
if runtime.platformType == "win32" and os.path.isfile(finalname):
os.remove(finalname)
os.rename(filename, finalname)
log.msg("Saved.")
# "Persistant" has been present since 1.0.7, so retain it for compatibility
Persistant = Persistent
components.backwardsCompatImplements(Persistent)
class _EverythingEphemeral(styles.Ephemeral):
initRun = 0
def __getattr__(self, key):
try:
return getattr(mainMod, key)
except AttributeError:
if self.initRun:
raise
else:
log.msg("Warning! Loading from __main__: %s" % key)
return styles.Ephemeral()
if self.client[0] not in ('INET', 'SSL'):
return None
host = self.client[1]
try:
name, names, addresses = socket.gethostbyaddr(host)
except socket.error:
return host
names.insert(0, name)
for name in names:
if '.' in name:
return name
return names[0]
def connectionLost(self, reason):
"""connection was lost"""
pass
components.backwardsCompatImplements(Request)
class HTTPChannel(basic.LineReceiver, policies.TimeoutMixin):
"""A receiver for HTTP requests."""
maxHeaders = 500 # max number of headers allowed per request
length = 0
persistent = 1
__header = ''
__first_line = 1
__content = None
requestFactory = Request
_savedTimeOut = None
def __init__(self):
self.requests = []
def connectionMade(self):
self.setTimeout(self.timeOut)
def lineReceived(self, line):
class IChangeNotified:
pass
class BaseChangeNotified:
implements(IChangeNotified)
def reportChange(self, old, new):
pass
def reportNoChange(self):
pass
components.backwardsCompatImplements(BaseChangeNotified)
class ChangeChecker:
working = 0
call = None
def __init__(self, notified, url, delay=60):
self.notified = notified
self.url = url
self.md5 = None
self.delay = delay
def start(self):
self.working = 1
"""
ext, dumpFunc = self._getStyle()
if passphrase:
ext = "e" + ext
finalname, filename = self._getFilename(filename, ext, tag)
log.msg("Saving " + self.name + " application to " + finalname + "...")
self._saveTemp(filename, passphrase, dumpFunc)
if runtime.platformType == "win32" and os.path.isfile(finalname):
os.remove(finalname)
os.rename(filename, finalname)
log.msg("Saved.")
# "Persistant" has been present since 1.0.7, so retain it for compatibility
Persistant = Persistent
components.backwardsCompatImplements(Persistent)
class _EverythingEphemeral(styles.Ephemeral):
initRun = 0
def __getattr__(self, key):
try:
return getattr(mainMod, key)
except AttributeError:
if self.initRun:
raise
else:
log.msg("Warning! Loading from __main__: %s" % key)
return styles.Ephemeral()
Internal utility class to simplify the definition of \"new-style\"
mktap plugins based on existing, \"classic\" mktap plugins.
"""
implements(IPlugin, IServiceMaker)
def __init__(self, name, module, description, tapname):
self.name = name
self.module = module
self.description = description
self.tapname = tapname
def options():
def get(self):
return namedAny(self.module).Options
return get,
options = property(*options())
def makeService():
def get(self):
return namedAny(self.module).makeService
return get,
makeService = property(*makeService())
backwardsCompatImplements(_tapHelper)
self.args = args
self.kwargs = kwargs
def execute(self, svc, commandTime):
if not hasattr(self, "obj"):
obj = svc.loadObject(self.objType, self.objId)
else:
obj = self.obj
return getattr(obj, self.methodName)(*self.args, **self.kwargs)
def __getstate__(self):
d = self.__dict__.copy()
del d["obj"]
return d
components.backwardsCompatImplements(WrapperCommand)
def command(methodName, cmdClass=WrapperCommand):
"""Wrap a method so it gets turned into command automatically.
For use with Wrappables.
Usage::
| class Foo(Wrappable):
| objectType = "foo"
| def getUid(self):
| return self.id
| def _bar(self, x):
| return x + 1
return 'loopback'
def getPeer(self):
return 'loopback'
def registerProducer(self, producer, streaming):
self.producer = producer
def unregisterProducer(self):
self.producer = None
def logPrefix(self):
return 'Loopback(%r)' % (self.target.__class__.__name__, )
components.backwardsCompatImplements(LoopbackRelay)
def loopback(server, client, logFile=None):
"""Run session between server and client.
"""
from twisted.internet import reactor
serverToClient = LoopbackRelay(client, logFile)
clientToServer = LoopbackRelay(server, logFile)
server.makeConnection(serverToClient)
client.makeConnection(clientToServer)
while 1:
reactor.iterate(0.01) # this is to clear any deferreds
serverToClient.clearBuffer()
clientToServer.clearBuffer()
if serverToClient.shouldLose:
from twisted.trial.itrial import IReporter
from twisted.plugin import IPlugin
class _Reporter(object):
implements(IPlugin, IReporter)
def __init__(self, name, module, description, longOpt, shortOpt, klass):
self.name = name
self.module = module
self.description = description
self.longOpt = longOpt
self.shortOpt = shortOpt
self.klass = klass
backwardsCompatImplements(_Reporter)
Tree = _Reporter("Tree Reporter",
"twisted.trial.reporter",
description="verbose color output (default reporter)",
longOpt="verbose",
shortOpt="v",
klass="TreeReporter")
BlackAndWhite = _Reporter("Black-And-White Reporter",
"twisted.trial.reporter",
description="Colorless verbose output",
longOpt="bwverbose",
shortOpt="o",
klass="VerboseTextReporter")
def unregisterProducer(self):
self.producer = None
def write(self, chunk):
self.chunks.append(chunk)
def sendNextPage(self):
if self.pointer >= len(self.chunks):
return
val = self.chunks[self.pointer]
self.pointer += 1
self.producer.resumeProducing()
self.collector.callRemote("gotPage", val)
components.backwardsCompatImplements(FilePager)
### Utility paging stuff.
from twisted.spread import pb
class CallbackPageCollector(pb.Referenceable):
"""I receive pages from the peer. You may instantiate a Pager with a
remote reference to me. I will call the callback with a list of pages
once they are all received."""
def __init__(self, callback):
self.pages = []
self.callback = callback
def remote_gotPage(self, page):
self.pages.append(page)
def remote_endedPaging(self):
self.callback(self.pages)
return (self._bwHack, self.name)[start:stop]
def __eq__(self, other):
if isinstance(other, tuple):
return tuple(self) == other
elif isinstance(other, UNIXAddress):
try:
return os.path.samefile(self.name, other.name)
except OSError:
pass
return False
def __str__(self):
return 'UNIXSocket(%r)' % (self.name,)
components.backwardsCompatImplements(IPv4Address)
components.backwardsCompatImplements(UNIXAddress)
# These are for buildFactory backwards compatability due to
# stupidity-induced inconsistency.
class _ServerFactoryIPv4Address(IPv4Address):
"""Backwards compatability hack. Just like IPv4Address in practice."""
def __eq__(self, other):
if isinstance(other, tuple):
warnings.warn("IPv4Address.__getitem__ is deprecated. Use attributes instead.",
category=DeprecationWarning, stacklevel=2)
return (self.host, self.port) == other
elif isinstance(other, IPv4Address):
It will be called, for example, before an application shuts down,
if it was connected to a port. User code should not call this function
directly.
"""
def buildProtocol(self, addr):
"""Create an instance of a subclass of Protocol.
The returned instance will handle input on an incoming server
connection, and an attribute \"factory\" pointing to the creating
factory.
Override this method to alter how Protocol instances get created.
@param addr: an object implementing L{twisted.internet.interfaces.IAddress}
"""
p = self.protocol()
p.factory = self
return p
components.backwardsCompatImplements(Factory)
class ClientFactory(Factory):
"""A Protocol factory for clients.
This can be used together with the various connectXXX methods in
reactors.
"""
def startedConnecting(self, connector):
"""Called when a connection has been started.
You can call connector.stopConnecting() to stop the connection attempt.
@param connector: a Connector object.
"""
def clientConnectionFailed(self, connector, reason):
"""Called when a connection has failed to connect.
It may be useful to call connector.connect() - this will reconnect.
@type reason: L{twisted.python.failure.Failure}
"""
"""
log.msg('attached [%s]' % reflect.qual(self.__class__))
self._attachedCount = self._attachedCount + 1
if self._attachedCount == 1:
self.service.cachePerspective(self)
else:
log.msg(" (multiple references attached: %s)" % self._attachedCount)
return self
def detached(self, reference, identity):
"""Called when a broker is 'detached' from me.
See 'attached'.
When a remote actor disconnects (or times out, for example,
with HTTP), this is called in order to indicate that the
reference associated with that peer is no longer attached to
this perspective.
"""
log.msg('detached [%s]' % reflect.qual(self.__class__))
self._attachedCount = self._attachedCount - 1
if self._attachedCount <= 0:
self.service.uncachePerspective(self)
if self._attachedCount < 0:
log.msg(" (Weird stuff: attached count = %s)" % self._attachedCount)
else:
log.msg(" (multiple references attached: %s)" % self._attachedCount)
return self
components.backwardsCompatImplements(Perspective)
def buildProtocol(self, addr):
"""Create an instance of a subclass of Protocol.
The returned instance will handle input on an incoming server
connection, and an attribute \"factory\" pointing to the creating
factory.
Override this method to alter how Protocol instances get created.
@param addr: an object implementing L{twisted.internet.interfaces.IAddress}
"""
p = self.protocol()
p.factory = self
return p
components.backwardsCompatImplements(Factory)
class ClientFactory(Factory):
"""A Protocol factory for clients.
This can be used together with the various connectXXX methods in
reactors.
"""
def startedConnecting(self, connector):
"""Called when a connection has been started.
You can call connector.stopConnecting() to stop the connection attempt.
@param connector: a Connector object.