def makeConfigurable(self, cfgInfo, container, name): """Create a new configurable to a container, based on input from web form.""" cmd, args = string.split(cfgInfo, ' ', 1) if cmd == "new": # create obj = coil.createConfigurable(reflect.namedClass(args), container, name) elif cmd == "dis": # dispense methodHash = int(args) if components.implements(container, coil.IConfigurator) and container.getType(name): interface = container.getType(name) elif components.implements(container, coil.IConfigCollection): interface = container.entityType else: interface = None for t in self.dispensers.getDispensers(interface): obj, methodName, desc = t if hash(t) == methodHash: cfg = coil.getConfigurator(obj) obj = getattr(cfg, methodName)() print "created %s from dispenser" % obj break else: raise ValueError, "Unrecognized command %r in cfgInfo %r" % (cmd, cfgInfo) self.dispensers.addObject(obj) return obj
def testInstances(self): o = MultiplyAndAdd() self.assert_( components.implements(o, IMultiply) ) self.assert_( components.implements(o, IMultiply) ) o = Sub() self.assert_( components.implements(o, IAdder) ) self.assert_( components.implements(o, ISub) )
def _displayNext(self, next): if next is None: # we're done self.destroy() elif tpc.implements(next, IPage): self._displayPage(next) elif tpc.implements(next, IWizard): self.startWizard(next)
def testOldSubclass(self): class IFoo(components.Interface): pass class ThirdParty(Zoper): __implements__ = Zoper.__implements__, IFoo self.assert_(components.implements(ThirdParty(), IAdder)) self.assert_(components.implements(ThirdParty(), IFoo)) self.assert_(components.implements(ThirdParty(), IZope))
def testOldSubclass(self): # someone has third party class that subclasses Zoper, # and expects Zoper to have __implements__ since Zoper # was originally written for twisted 1.3, pre zope.interface class IFoo(components.Interface): pass class ThirdParty(Zoper): __implements__ = Zoper.__implements__, IFoo self.assert_(components.implements(ThirdParty(), IAdder)) self.assert_(components.implements(ThirdParty(), IFoo)) self.assert_(components.implements(ThirdParty(), IZope))
def __init__(self, interface, proto, maxPacketSize=8192, reactor=None): if components.implements(proto, ethernet.IEthernetProtocol): self.ethernet = 1 else: self.ethernet = 0 assert components.implements(proto, ip.IIPProtocol) # XXX: fix me base.BasePort.__init__(self, reactor) self.interface = interface self.protocol = proto self.maxPacketSize = maxPacketSize self.setLogStr()
def addDomain(self, name, domain): portal = cred.portal.Portal(domain) map(portal.registerChecker, domain.getCredentialsCheckers()) self.domains[name] = domain self.portals[name] = portal if self.aliases and components.implements(domain, IAliasableDomain): domain.setAliasGroup(self.aliases)
def maildirDbmFactory(container, name): if components.implements(container, coil.IConfigurator): container = container.getInstance() path = os.path.join(container.storagePath, name) if not os.path.exists(path): os.makedirs(path) return maildir.MaildirDirdbmDomain(path)
def configure(self, dict): """Set a list of configuration variables.""" items = dict.items() for name, value in items: t = self.getType(name) if isinstance(t, types.TypeType): if not isinstance(value, t) or (value is None): raise InvalidConfiguration("type mismatch") elif isinstance(t, types.ClassType) and issubclass(t, components.Interface): if not components.implements(value, t) or (value is None): raise InvalidConfiguration("type mismatch") elif t == 'boolean': try: if value: pass except: raise InvalidConfiguration("non-boolean for boolean type") else: raise InvalidConfiguration("Configuration item '%s' has " "unknown type '%s'" % (name, t)) for name, value in items: func = getattr(self, "config_%s" % name, None) if func: func(value) else: setattr(self.instance, name, value)
def entityConstraint(self, entity): if isinstance(self.entityType, types.TypeType) and isinstance(entity, self.entityType): return 1 elif components.implements(entity, self.entityType): return 1 else: raise roots.ConstraintViolation("%s of incorrect type (%s)" % (entity, self.entityType))
def _disconnected(self, _): self.xmlstream = None # Notify all child services which implement # the IService interface for c in self: if components.implements(c, IService): c.componentDisconnected()
def _authd(self, xs): # Flush all pending packets for p in self._packetQueue: self.xmlstream.send(p) self._packetQueue = [] # Notify all child services which implement # the IService interface for c in self: if components.implements(c, IService): c.componentConnected(xs)
def _grabService(self, svc, sclas): """ Find an instance of a particular class in a service collection and all subcollections. """ for s in svc.services.values(): if isinstance(s, sclas): return s if components.implements(s, IServiceCollection): ss = self._grabService(s, sclas) if ss: return ss
def registerControllerForModel(controller, model): """ Registers `controller' as an adapter of `model' for IController, and optionally registers it for IResource, if it implements it. @param controller: A class that implements L{interfaces.IController}, usually a L{Controller} subclass. Optionally it can implement L{resource.IResource}. @param model: Any class, but probably a L{twisted.web.woven.model.Model} subclass. """ components.registerAdapter(controller, model, interfaces.IController) if components.implements(controller, resource.IResource): components.registerAdapter(controller, model, resource.IResource)
def getMapper(self, x): if components.implements(x, ITypeMapper): if isinstance(x, (ClassType, type)): return x() return x if isinstance(x, Ref): x = x() if x in self._mapperCache: return self._mapperCache[x] else: if isinstance(x, tuple): ot = TupleTypeMapper(x) elif issubclass(x, Storable): ot = ObjectTypeMapper(x) else: raise NotImplementedError("You can't store that.") self._mapperCache[x] = ot return ot
def reactorCleanUp(): from twisted.internet import reactor reactor.iterate() # flush short-range timers pending = reactor.getDelayedCalls() if pending: msg = "\npendingTimedCalls still pending:\n" for p in pending: msg += " %s\n" % p from warnings import warn warn(msg) for p in pending: p.cancel() # delete the rest reactor.iterate() # flush them raise unittest.FailTest, msg if components.implements(reactor, interfaces.IReactorThreads): reactor.suggestThreadPoolSize(0) if hasattr(reactor, 'threadpool') and reactor.threadpool: reactor.threadpool.stop() reactor.threadpool = None
def testBasicLogin(self): l = []; f = [] self.portal.login(credentials.UsernamePassword("bob", "hello"), self, ITestable).addCallback( l.append).addErrback(f.append) if f: raise f[0] # print l[0].getBriefTraceback() iface, impl, logout = l[0] # whitebox self.assertEquals(iface, ITestable) self.failUnless(components.implements(impl, iface), "%s does not implement %s" % (impl, iface)) # greybox self.failUnless(impl.original.loggedIn) self.failUnless(not impl.original.loggedOut) logout() self.failUnless(impl.original.loggedOut)
def opt_aliases(self, filename): """Specify an aliases(5) file to use for this domain""" if self.last_domain: if components.implements(self.last_domain, mail.IAliasableDomain): aliases = alias.loadAliasFile(self.service.domains, filename) self.last_domain.setAliasGroup(aliases) self.service.monitor.monitorFile( filename, AliasUpdater(self.service.domains, self.last_domain) ) else: raise usage.UsageError( "%s does not support alias files" % ( self.last_domain.__class__.__name__, ) ) else: raise usage.UsageError("Specify a domain before specifying aliases")
def process(self, write, request, submit, name="", type=None, items=()): # write(str(('YAY', name, type))) # TODO: validation on the name? if submit == 'Delete': for item in items: obj = self.coll.getStaticEntity(item) if components.implements(obj, coil.IConfigurator): obj = obj.getInstance() self.configurator.dispensers.removeObject(obj) self.coll.delEntity(item) write("<b>Items Deleted.</b><br>(%s)<br>" % html.escape(repr(items))) elif submit == "Insert": obj = self.configurator.makeConfigurable(type, self.coll, name) self.coll.putEntity(name, obj) write("<b>%s created!</b>" % type) else: raise widgets.FormInputError("Don't know how to %s" % repr(submit)) self.format(self.getFormFields(request), write, request)
def configWidget(self, request): """Render the config part of the widget.""" path = request.postpath if path: obj = self.app for elem in path: if elem: # '' doesn't count collection = coil.getCollection(obj) if collection is None: obj = None else: obj = collection.getStaticEntity(elem) if obj is None: # no such subobject request.redirect(request.prePathURL()) return ['Redirecting...'] else: obj = self.app ret = [] linkfrom = string.join(['config']+request.postpath, '/') + '/' cfg = coil.getConfigurator(obj) # add a form for configuration if available if cfg and cfg.configTypes: ret.extend(widgets.TitleBox("Configuration", ConfigForm(self, cfg, linkfrom)).display(request)) # add a form for a collection of objects coll = coil.getCollection(obj) if components.implements(coll, coil.IConfigCollection): if coll.entityType in (types.StringType, types.IntType, types.FloatType): ret.extend(widgets.TitleBox("Delete Items", ImmutableCollectionDeleteForm(self, coll, linkfrom)).display(request)) colClass = ImmutableCollectionForm else: colClass = CollectionForm ret.extend(widgets.TitleBox("Listing", colClass(self, coll, linkfrom)).display(request)) ret.append(html.PRE(str(obj))) return ret
def _cbMailbox(self, ial, user): if isinstance(ial, Mailbox) or components.implements(ial, IMailbox): import warnings warnings.warn( "POP3.authenticateUser*() methods must now return a 3-tuple," "not a Mailbox. Please update your code.", DeprecationWarning, 1 ) interface = IMailbox avatar = ial logout = lambda: None else: interface, avatar, logout = ial if interface is not IMailbox: self.failResponse('Authentication failed') log.err("_cbMailbox() called with an interface other than IMailbox") return self.mbox = avatar self._onLogout = logout self.successResponse('Authentication succeeded') log.msg("Authenticated login for " + user)
def testGetSubAdapter(self): o = MultiplyAndAdd() self.assert_( not components.implements(o, IFoo) ) foo = components.getAdapter(o, IFoo, None) self.assert_( isinstance(foo, FooAdapterForMAA) )
def testNewSubclass(self): # new-style implementing class subclasses backwardsCompatImplements class o = SubZoper() self.assert_(components.implements(o, IZope)) self.assert_(components.implements(o, ISub))
def testNewSubclassOfOld(self): o = NewSubOfOldStyle() self.assert_(components.implements(o, IZope)) self.assert_(components.implements(o, IAdder))
def __init__(self, configurator, cfgr, linkfrom): if not components.implements(cfgr, coil.IConfigurator): raise TypeError self.configurator = configurator # this is actually a AppConfiguratorPage self.cfgr = cfgr self.linkfrom = linkfrom
def _connected(self, xs): self.xmlstream = xs for c in self: if components.implements(c, IService): c.transportConnected(xs)
def testOther(self): self.assert_( not components.implements(3, ISub) ) self.assert_( not components.implements("foo", ISub) )
class Factory(protocol.Factory): def buildProtocol(self, addr): return protocol.Protocol() class UnixSocketTestCase(test_smtp.LoopbackSMTPTestCase): """Test unix sockets.""" def loopback(self, client, server): loopback.loopbackUNIX(client, server) def testDumber(self): filename = tempfile.mktemp() l = reactor.listenUNIX(filename, Factory()) reactor.connectUNIX(filename, TestClientFactory()) for i in xrange(100): reactor.iterate() l.stopListening() def testMode(self): filename = tempfile.mktemp() l = reactor.listenUNIX(filename, Factory(), mode = 0600) self.assertEquals(stat.S_IMODE(os.stat(filename)[0]), 0600) reactor.connectUNIX(filename, TestClientFactory()) for i in xrange(100): reactor.iterate() l.stopListening() if not components.implements(reactor, interfaces.IReactorUNIX): del UnixSocketTestCase
def testNewSubclass(self): o = SubZoper() self.assert_(components.implements(o, IZope)) self.assert_(components.implements(o, ISub))
def __init__(self, forwarded, interfaceClass, failWhenNotImplemented=0): assert implements(forwarded, interfaceClass) self.forwarded = forwarded self.interfaceClass = interfaceClass self.failWhenNotImplemented = failWhenNotImplemented
pyExe = sys.executable scriptPath = util.sibpath(__file__, "process_stdinreader.py") p = Accumulator() reactor.spawnProcess(p, pyExe, [pyExe, "-u", scriptPath], env=None, path=None) p.transport.write("hello, world") p.transport.closeStdin() while not p.closed: reactor.iterate() self.assertEquals(p.errF.getvalue(), "err\nerr\n") self.assertEquals(p.outF.getvalue(), "out\nhello, world\nout\n") skipMessage = "wrong platform or reactor doesn't support IReactorProcess" if (runtime.platform.getType() != 'posix') or (not components.implements(reactor, interfaces.IReactorProcess)): PosixProcessTestCase.skip = skipMessage PosixProcessTestCasePTY.skip = skipMessage TestTwoProcessesPosix.skip = skipMessage else: # do this before running the tests: it uses SIGCHLD and stuff internally lsOut = popen2.popen3("/bin/ls ZZXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")[2].read() # make sure SIGCHLD handler is installed, as it should be on reactor.run(). # problem is reactor may not have been run when this test runs. if hasattr(reactor, "_handleSigchld"): import signal from twisted.internet import process signal.signal(signal.SIGCHLD, reactor._handleSigchld) if (runtime.platform.getType() != 'win32') or (not components.implements(reactor, interfaces.IReactorProcess)): Win32ProcessTestCase.skip = skipMessage
def testInstanceOnlyImplements(self): class Blah: pass o = Blah() o.__implements__ = IAdder self.assert_( components.implements(o, IAdder) )
def getCollection(obj): """Get an object implementing ICollection for obj.""" if components.implements(obj, IConfigurator): obj = obj.getInstance() return components.getAdapter(obj, ICollection, None)