def setUp(self): db = inmemory.ReadOnlyInMemoryLDAPEntry('', {}) com = db.addChild('dc=com', {'objectClass': ['dcObject'], 'dc': ['com'], }) com.addChild('dc=example', {'objectClass': ['dcObject'], 'dc': ['example'], 'subschemaSubentry': ['cn=schema'], }) db.addChild('cn=schema', {'objectClass': ['TODO'], 'cn': ['schema'], 'attributeTypes': [test_schema.AttributeType_KnownValues.knownValues[0][0]], 'objectClasses': [test_schema.OBJECTCLASSES['organization'], test_schema.OBJECTCLASSES['organizationalUnit'], ], }) class LDAPServerFactory(protocol.ServerFactory): protocol = ldapserver.LDAPServer def __init__(self, root): self.root = root components.registerAdapter(lambda x: x.root, LDAPServerFactory, interfaces.IConnectedLDAPEntry) serverFactory = LDAPServerFactory(db) self.client = ldapclient.LDAPClient() server = serverFactory.buildProtocol(address.IPv4Address('TCP', 'localhost', '1024')) util.returnConnected(server, self.client)
def registerCustomFieldSerializer(serializerClass, typeClass): """Register a custom field serializer for a specific type. """ registerAdapter( serializerClass, typeClass, igwt.ICustomFieldSerializer ) registerTypeClass(typeClass)
def run(): args = PARSER.parse_args() # Unpack values. Each should be a list of one item (hence the # comma. Yay list unpacking) private_key, = args.private_key public_key, = args.public_key webserver_address, = args.webserver_address webserver_user, = args.webserver_user webserver_password, = args.webserver_password port = int(args.port) log.startLogging(sys.stderr) log.startLogging(open('gitssh.log', 'w')) components.registerAdapter(GitSession, GitConchUser, ISession) # Set up authorization GitServer.meta = GitMeta(webserver_address, webserver_user, webserver_password) GitServer.portal = Portal(GitRealm(GitServer.meta)) GitServer.portal.registerChecker(TeamPasswordChecker(GitServer.meta)) # Instantiate a server server = GitServer(os.path.abspath(private_key), os.path.abspath(public_key)) # Start listening reactor.listenTCP(port, server) reactor.run()
def start(): from checker import PublicKeyCredentialsChecker from factory import ForwardFactory from realm import ForwardRealm from session import ForwardSession from twisted.conch.ssh import session from twisted.cred import portal from twisted.internet import reactor from twisted.python import components, log from twisted.web import server import sys from user import ForwardUser from conf import config import web log.startLogging(sys.stderr) components.registerAdapter(ForwardSession, ForwardUser, session.ISession) portal = portal.Portal(ForwardRealm()) portal.registerChecker(PublicKeyCredentialsChecker()) ForwardFactory.portal = portal print "running server on %s:%s" % (config['SSH_INTERFACE'],config['SSH_PORT']) reactor.listenTCP( port=config['SSH_PORT'], interface=config['SSH_INTERFACE'], factory=ForwardFactory() ) reactor.listenTCP(port=config['WEB_PORT'], interface=config['WEB_INTERFACE'], factory=server.Site(web.MainSite())) reactor.run()
def check_config_base(): from mypkg import config, interfaces, usesconfig components.registerAdapter( AdaptRunningConfigToMyConfig, config.MyConfig, IMyConfig) print usesconfig.do_a_config_thing()
def makeService(config): components.registerAdapter( GitSession, GitAvatar, session.ISession) with open(config['conf']) as f: conf = yaml.load(f.read()) port = int(conf.get('port', 22)) host_key = conf.get('host_key') driver_key = conf.get('driver', 'example') log.msg('Using driver: \'%s\'' % driver_key) mgr = driver.DriverManager( namespace='gitserver.driver', name=driver_key, invoke_on_load=False ) portal = Portal(GitRealm(mgr)) portal.registerChecker(GitPublicKeyChecker(mgr)) # factory.SSHFactory takes no arguments, so unlike the # websocket server, we will assign portal on the class # rather than through the constructor. # TypeError: this constructor takes no arguments # is raised if we pass portal GitFactory(portal) GitFactory.portal = portal GitSession.driver_key = driver_key return internet.TCPServer(port, GitFactory(host_key=host_key))
def setUp(self): db = inmemory.ReadOnlyInMemoryLDAPEntry("", {}) com = db.addChild("dc=com", {"objectClass": ["dcObject"], "dc": ["com"]}) com.addChild("dc=example", {"objectClass": ["dcObject"], "dc": ["example"], "subschemaSubentry": ["cn=schema"]}) db.addChild( "cn=schema", { "objectClass": ["TODO"], "cn": ["schema"], "attributeTypes": [test_schema.AttributeType_KnownValues.knownValues[0][0]], "objectClasses": [ test_schema.OBJECTCLASSES["organization"], test_schema.OBJECTCLASSES["organizationalUnit"], ], }, ) class LDAPServerFactory(protocol.ServerFactory): protocol = ldapserver.LDAPServer def __init__(self, root): self.root = root components.registerAdapter(lambda x: x.root, LDAPServerFactory, interfaces.IConnectedLDAPEntry) serverFactory = LDAPServerFactory(db) self.client = ldapclient.LDAPClient() server = serverFactory.buildProtocol(address.IPv4Address("TCP", "localhost", "1024")) util.returnConnected(server, self.client)
def test_basic(self): """ Registered adapters can be used to adapt classes to an interface. """ components.registerAdapter(MetaAdder, MetaNumber, IMeta) n = MetaNumber(1) self.assertEqual(IMeta(n).add(1), 2)
def main(argv=sys.argv[1:]): parser = argparse.ArgumentParser() parser.add_argument( '-c', '--config', help=( 'Path to the configuration file. If not specified then the ' 'lookup order will check for a HADOUKN_GIT_CONFIG environ ' 'variable, then fallback to .hadoukngitrc in the CWD.' ), default='hadoukngit.ini' ) args = parser.parse_args(args=argv) cfg_path = args.config if cfg_path is not None and not os.path.exists(cfg_path): print('Invalid path "{}" specified for the config file.' .format(cfg_path), file=sys.stderr) return 1 config = get_config(cfg_path) settings = config.get_dict() factory = SSHFactory(settings) # adapting User to GitSession which implements ISession components.registerAdapter(GitSession, User, ISession) port = int(settings['hadoukngit']['port']) # Run the server logger.info('Serving on localhost:%s...' % port) reactor.listenTCP(port, factory) reactor.run()
def _duplicateAdapterForClassOrInterfaceAllowed(self, original): """ Verify that when C{components.ALLOW_DUPLICATES} is set to C{True}, new adapter registrations for a particular from-type/interface and to-interface pair replace older registrations. """ firstAdapter = lambda o: False secondAdapter = lambda o: True class TheInterface(Interface): pass components.registerAdapter(firstAdapter, original, TheInterface) components.ALLOW_DUPLICATES = True try: components.registerAdapter(secondAdapter, original, TheInterface) self.assertIs( components.getAdapterFactory(original, TheInterface, None), secondAdapter) finally: components.ALLOW_DUPLICATES = False # It should be rejected again at this point self.assertRaises( ValueError, components.registerAdapter, firstAdapter, original, TheInterface) self.assertIs( components.getAdapterFactory(original, TheInterface, None), secondAdapter)
def _registerAdapterForClassOrInterface(self, original): adapter = lambda o: None class TheInterface(Interface): pass components.registerAdapter(adapter, original, TheInterface) self.assertIdentical( components.getAdapterFactory(original, TheInterface, None), adapter)
def load(S): for line in S.split('\n'): line = line.strip() if line and not line.startswith('#'): (a, o, i) = line.split() registerAdapter(_namedAnyWithBuiltinTranslation(a), _namedAnyWithBuiltinTranslation(clean(o)), _namedAnyWithBuiltinTranslation(i))
def testComponentized(self): components.registerAdapter(Adept, Compo, IAdept) components.registerAdapter(Elapsed, Compo, IElapsed) c = Compo() assert c.getComponent(IAdept).adaptorFunc() == (1, 1) assert c.getComponent(IAdept).adaptorFunc() == (2, 2) assert IElapsed(IAdept(c)).elapsedFunc() == 1
def check_app_inherited(): from otherpkg import config class OtherApp(object): def get_config(self): return "config.name = 'other app'" components.registerAdapter( AdaptRunningAppToMyApp, OtherApp, IMyApp)
def register(): """Register this component """ try: components.registerAdapter(MambaSQLAdapter, MySQL, IMambaSQL) except ValueError: # component already registered pass
def registerTypeAdapter(typeClass, instanceClass): """Associate a value class with an type. This enables us to lookup the type for a value by simply adopting it to IType. This is mostly used for exceptions. """ def adapter(original): return typeClass() registerAdapter(adapter, instanceClass, igwt.IType)
def run(self, port=5022): components.registerAdapter(self.SSHSession, self.User, session.ISession) p = portal.Portal(self.SSHRealm()) p.registerChecker(self.KeyChecker()) self.SSHFactory.portal = p reactor.listenTCP(int(port), self.SSHFactory()) reactor.run()
def __init__(self, cfg, tls_options, *args): self.debug = True self.tree = Tree() self.root = self.tree.db self.options = tls_options registerAdapter( lambda x: x.root, LdapProtocolFactory, IConnectedLDAPEntry)
def callback(instanceClass): class InstanceFactory: def __init__(self, protocolClass): pass def buildInstance(self): return instanceClass() components.registerAdapter(InstanceFactory, typeClass, igwt.IInstanceFactory) annotation.registerTypeAdapter(typeClass, instanceClass) return instanceClass
def testAllowDuplicates(self): components.ALLOW_DUPLICATES = 1 try: components.registerAdapter(IntMultiplyWithAdder, IntAdder, IMultiply) except ValueError: self.fail("Should have allowed re-registration") components.ALLOW_DUPLICATES = 0 self.assertRaises(ValueError, components.registerAdapter, IntMultiplyWithAdder, IntAdder, IMultiply)
def _registerAdapterForClassOrInterface(self, original): """ Register an adapter with L{components.registerAdapter} for the given class or interface and verify that the adapter can be looked up with L{components.getAdapterFactory}. """ adapter = lambda o: None components.registerAdapter(adapter, original, ITest) self.assertIs( components.getAdapterFactory(original, ITest, None), adapter)
def _multipleInterfacesForClassOrInterface(self, original): """ Verify that an adapter can be registered for multiple to-interfaces at a time. """ adapter = lambda o: None components.registerAdapter(adapter, original, ITest, ITest2) self.assertIs( components.getAdapterFactory(original, ITest, None), adapter) self.assertIs( components.getAdapterFactory(original, ITest2, None), adapter)
def check_config_inherited(): from mypkg import usesconfig from otherpkg import config class OtherConfig(object): def get_attr(self): return "an other attr datum" components.registerAdapter( AdaptRunningConfigToMyConfig, config.OtherConfig, IMyConfig) print usesconfig.do_a_config_thing()
def testMultipleInterfaceRegistration(self): class IMIFoo(components.Interface): pass class IMIBar(components.Interface): pass class MIFooer(components.Adapter): zinterface.implements(IMIFoo, IMIBar) class Blegh: pass components.registerAdapter(MIFooer, Blegh, IMIFoo, IMIBar) self.assert_(isinstance(IMIFoo(Blegh()), MIFooer)) self.assert_(isinstance(IMIBar(Blegh()), MIFooer))
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 resource.IResource.implementedBy(controller): components.registerAdapter(controller, model, resource.IResource)
def _try_receiving(port, count): dhnio.Dprint(10, "transport_ssh.receive count=%d" % count) components.registerAdapter(None, MyAvatar, session.ISession) d = Deferred() myrealm = MyRealm(d) portal_ = portal.Portal(myrealm) portal_.registerChecker(MyPublicKeyChecker()) MyFactory.portal = portal_ try: mylistener = reactor.listenTCP(port, MyFactory()) except: mylistener = None return mylistener
def check_app_base(): from mypkg import config class IMyApp(Interface): def get_config(): pass class MyApp(object): def get_config(self): return "config.name = 'my app'" components.registerAdapter( AdaptRunningAppToMyApp, MyApp, IMyApp)
def _multipleInterfacesForClassOrInterface(self, original): adapter = lambda o: None class FirstInterface(Interface): pass class SecondInterface(Interface): pass components.registerAdapter(adapter, original, FirstInterface, SecondInterface) self.assertIdentical( components.getAdapterFactory(original, FirstInterface, None), adapter) self.assertIdentical( components.getAdapterFactory(original, SecondInterface, None), adapter)
def _duplicateAdapterForClassOrInterface(self, original): firstAdapter = lambda o: False secondAdapter = lambda o: True class TheInterface(Interface): pass components.registerAdapter(firstAdapter, original, TheInterface) self.assertRaises( ValueError, components.registerAdapter, secondAdapter, original, TheInterface) # Make sure that the original adapter is still around as well self.assertIdentical( components.getAdapterFactory(original, TheInterface, None), firstAdapter)
def _subclassAdapterRegistrationForClassOrInterface(self, original): firstAdapter = lambda o: True secondAdapter = lambda o: False class TheSubclass(original): pass class TheInterface(Interface): pass components.registerAdapter(firstAdapter, original, TheInterface) components.registerAdapter(secondAdapter, TheSubclass, TheInterface) self.assertIdentical( components.getAdapterFactory(original, TheInterface, None), firstAdapter) self.assertIdentical( components.getAdapterFactory(TheSubclass, TheInterface, None), secondAdapter)
from buildbot.interfaces import IConfigured from twisted.python.components import registerAdapter from zope.interface import implements class _DefaultConfigured(object): implements(IConfigured) def __init__(self, value): self.value = value def getConfigDict(self): return self.value registerAdapter(_DefaultConfigured, object, IConfigured) class _ListConfigured(object): implements(IConfigured) def __init__(self, value): self.value = value def getConfigDict(self): return [IConfigured(e).getConfigDict() for e in self.value] registerAdapter(_ListConfigured, list, IConfigured)
self.step_status.addURL(name, url) def runCommand(self, c): self.cmd = c c.buildslave = self.buildslave d = c.run(self, self.remote) return d @staticmethod def _maybeEvaluate(value, *args, **kwargs): if callable(value): value = value(*args, **kwargs) return value components.registerAdapter(BuildStep._getStepFactory, BuildStep, interfaces.IBuildStepFactory) components.registerAdapter(lambda step: interfaces.IProperties(step.build), BuildStep, interfaces.IProperties) class OutputProgressObserver(LogObserver): length = 0 def __init__(self, name): self.name = name def logChunk(self, build, step, log, channel, text): self.length += len(text) self.step.setProgress(self.name, self.length)
raise NotImplementedError class UnixSFTPDirectory: def __init__(self, server, directory): self.server = server self.files = server.avatar._runAsUser(os.listdir, directory) self.dir = directory def __iter__(self): return self def next(self): try: f = self.files.pop(0) except IndexError: raise StopIteration else: s = self.server.avatar._runAsUser(os.lstat, os.path.join(self.dir, f)) longname = lsLine(f, s) attrs = self.server._getAttrs(s) return (f, longname, attrs) def close(self): self.files = [] components.registerAdapter(SFTPServerForUnixConchUser, UnixConchUser, filetransfer.ISFTPServer) components.registerAdapter(SSHSessionForUnixConchUser, UnixConchUser, session.ISession)
""" class _PortalRoot: """Root object, used to login to portal.""" implements(IPBRoot) def __init__(self, portal): self.portal = portal def rootObject(self, broker): return _PortalWrapper(self.portal, broker) registerAdapter(_PortalRoot, Portal, IPBRoot) class _JellyableAvatarMixin: """ Helper class for code which deals with avatars which PB must be capable of sending to a peer. """ def _cbLogin(self, (interface, avatar, logout)): """ Ensure that the avatar to be returned to the client is jellyable and set up disconnection notification to call the realm's logout object. """ if not IJellyable.providedBy(avatar): avatar = AsReferenceable(avatar, "perspective") self.broker.notifyOnDisconnect(logout)
class FingerFactoryFromService(protocol.ServerFactory): implements(IFingerFactory) protocol = FingerProtocol def __init__(self, service): self.service = service def getUser(self, user): return self.service.getUser(user) components.registerAdapter(FingerFactoryFromService, IFingerService, IFingerFactory) class FingerSetterProtocol(basic.LineReceiver): def connectionMade(self): self.lines = [] def lineReceived(self, line): self.lines.append(line) def connectionLost(self, reason): if len(self.lines) == 2: self.factory.setUser(*self.lines)
:Returns: `Deferred` to a tuple of (success, result) where success if a boolean that signifies success or failure and result is the task result. """ d = defer.succeed(None) d.addCallback(task.start_time) task.pre_task(d, self.queuedEngine) task.submit_task(d, self.queuedEngine) task.post_task(d, self.queuedEngine) d.addBoth(task.stop_time) d.addBoth(task.process_result, self.queuedEngine.id) # At this point, there will be (success, result) coming down the line return d components.registerAdapter(WorkerFromQueuedEngine, es.IEngineQueued, IWorker) class IScheduler(zi.Interface): """The interface for a Scheduler. """ zi.Attribute("nworkers", "the number of unassigned workers") zi.Attribute("ntasks", "the number of unscheduled tasks") zi.Attribute("workerids", "a list of the worker ids") zi.Attribute("taskids", "a list of the task ids") def add_task(task, **flags): """Add a task to the queue of the Scheduler. :Parameters: task : an `ITask` implementer The task to be queued.
pending = repr(self.currentCommand) else: pending = repr(None) dikt = {'queue': map(repr, self.queued), 'pending': pending} return defer.succeed(dikt) def register_failure_observer(self, obs): self.failureObservers.append(obs) def unregister_failure_observer(self, obs): self.failureObservers.remove(obs) # Now register QueuedEngine as an adpater class that makes an IEngineBase into a # IEngineQueued. components.registerAdapter(QueuedEngine, IEngineBase, IEngineQueued) class Command(object): """A command object that encapslates queued commands. This class basically keeps track of a command that has been queued in a QueuedEngine. It manages the deferreds and hold the method to be called and the arguments to that method. """ def __init__(self, remoteMethod, *args, **kwargs): """Build a new Command object.""" self.remoteMethod = remoteMethod self.args = args self.kwargs = kwargs
def addURL(self, name, url): self.step_status.addURL(name, url) def runCommand(self, c): c.buildslave = self.buildslave d = c.run(self, self.remote) return d @staticmethod def _maybeEvaluate(value, *args, **kwargs): if callable(value): value = value(*args, **kwargs) return value components.registerAdapter(lambda step: interfaces.IProperties(step.build), BuildStep, interfaces.IProperties) class OutputProgressObserver(LogObserver): length = 0 def __init__(self, name): self.name = name def logChunk(self, build, step, log, channel, text): self.length += len(text) self.step.setProgress(self.name, self.length) class LoggingBuildStep(BuildStep):
raise error.ConchError('bad exec') self.avatar.conn.transport.expectedLoseConnection = 1 def eofReceived(self): self.eof = 1 def closed(self): log.msg('closed cmd "%s"' % self.cmd) self.remoteWindowLeftAtClose = self.proto.session.remoteWindowLeft self.onClose.callback(None) from twisted.python import components if cryptography: components.registerAdapter(ConchSessionForTestAvatar, ConchTestAvatar, session.ISession) class CrazySubsystem(protocol.Protocol): def __init__(self, *args, **kw): pass def connectionMade(self): """ good ... good """ class FalseTransport: """ False transport should act like a /bin/false execution, i.e. just exit with
from ServeLib.Player import Player from SharedLib.component_hacks import registerIDs import ServeLib.ServerResource class ServerSite(Site, Adapter): implements(IServerSite) sessionFactory = Player def __init__(self, server): Adapter.__init__(self, server) Site.__init__(self, IResource(self)) reactor.callWhenRunning(self.startListening) def startListening(self): args = IMainSetup(42) if not args.verbose: self.log = lambda request: None log.msg("listening on %s:%s" % (args.interface, args.port)) reactor.listenTCP(args.port, self, interface=args.interface) def makeSession(self): player = Site.makeSession(self) return player registerAdapter(ServerSite, IGameServer, IServerSite)
if index == 0: if hasattr(self.original, "__class__"): v = self.original.__class__ else: v = type(self.original) return "__class__", v else: index -= 1 L = self.original.__dict__.items() L.sort() return L[index] import types for x in dict, types.DictProxyType: registerAdapter(DictionaryNode, x, INode) for x in list, tuple: registerAdapter(ListNode, x, INode) for x in int, str: registerAdapter(ConstantNode, x, INode) class InspectorTreeModel(gtk.GenericTreeModel): def __init__(self, root): gtk.GenericTreeModel.__init__(self) self.root = INode(root, persist=False) self.root.postInit(0, None, 'root') def on_get_flags(self): return 0
values: Optional[Mapping[str, str]] = None, method: Optional[str] = None, force_external: bool = False, append_unknown: bool = True, ) -> str: return buildURL( self.mapper, endpoint, values, method, force_external, append_unknown, ) registerAdapter(KleinRequest, Request, IKleinRequest) class Klein(object): """ L{Klein} is an object which is responsible for maintaining the routing configuration of our application. @ivar _url_map: A C{werkzeug.routing.Map} object which will be used for routing resolution. @ivar _endpoints: A C{dict} mapping endpoint names to handler functions. """ _subroute_segments = 0 def __init__(self) -> None:
return None, None @implementer(ISession) class _EnvironmentSSHSessionForUnixConchUser(SSHSessionForUnixConchUser): """ SSH Session that correctly sets HOME. Work-around for https://twistedmatrix.com/trac/ticket/7936. """ def execCommand(self, proto, cmd): self.environ['HOME'] = self.avatar.getHomeDir() return SSHSessionForUnixConchUser.execCommand(self, proto, cmd) registerAdapter(_EnvironmentSSHSessionForUnixConchUser, _FixedHomeConchUser, ISession) @implementer(IRealm) class _UnixSSHRealm(object): """ An ``IRealm`` for a Conch server which gives out ``_FixedHomeConchUser`` users. """ def __init__(self, home): self.home = home def requestAvatar(self, username, mind, *interfaces): user = _FixedHomeConchUser(username, self.home) return interfaces[0], user, user.logout
returns argument unchanged. """ implements(IRenderable) def __init__(self, value): try: self.renderer = value.getRenderingFor except AttributeError: self.renderer = lambda _: value def getRenderingFor(self, build): return self.renderer(build) registerAdapter(_DefaultRenderer, object, IRenderable) class _ListRenderer(object): """ List IRenderable adaptor. Maps Build.render over the list. """ implements(IRenderable) def __init__(self, value): self.value = value def getRenderingFor(self, build): return defer.gatherResults([build.render(e) for e in self.value])
# in case, there is no new line at the file end self.protocol.rawDataReceived(b'\n') # enforce to disconnect self.protocol.rawDataReceived(b'EOF\n') def closed(self): """ "Exit" was called """ #log.msg('~~~~~~ssh session from %s closed~~~~~~~' % self.avatar.addr) self.protocol.connectionLost('ssh section closed') #SSHSession enables ObjshAvatar to provide session.ISession components.registerAdapter(SSHSession, ObjshAvatar, session.ISession) @implementer(ICredentialsChecker) class CascadingChecker: """ Check multiple checkers untill one succeeds. Else raise UnauthorizedLogin. Credit: http://pepijndevos.nl/check-multiple-twistedcred-checkers-for-a-val/index.html """ #implements(ICredentialsChecker) credentialInterfaces = set() #ISSHPrivateKey def __init__(self):
if isinstance(qual, unicode): qual = qual.encode("utf-8") return qual, jellier.invoker.registerReference(self) def remote_join(self, groupName): def cbGroup(group): def cbJoin(ignored): return PBGroup(self.avatar.realm, self.avatar, group) d = self.avatar.join(group) d.addCallback(cbJoin) return d d = self.avatar.realm.getGroup(groupName) d.addCallback(cbGroup) return d registerAdapter(ChatAvatar, iwords.IUser, pb.IPerspective) class AvatarReference(pb.RemoteReference): def join(self, groupName): return self.callRemote('join', groupName) def quit(self): d = defer.Deferred() self.broker.notifyOnDisconnect(lambda: d.callback(None)) self.broker.transport.loseConnection() return d pb.setUnjellyableForClass(ChatAvatar, AvatarReference) @implementer(portal.IRealm, iwords.IChatService)
bytesRead = len(b) if not bytesRead: raise RuntimeError( "Ran out of data reading file %r, expected %d more bytes" % (self.f, length)) else: self.length -= bytesRead self.start += bytesRead return b def close(self): self.f = None SimpleStream.close(self) components.registerAdapter(FileStream, file, IByteStream) ############################## #### MemoryStream #### ############################## class MemoryStream(SimpleStream): """A stream that reads data from a buffer object.""" def __init__(self, mem, start=0, length=None): """ Create the stream from buffer object mem. If you specify start and length, use only that portion of the buffer. """ self.mem = mem self.start = start
warnings.warn( ("twisted.conch.unix imported %r, " "but doesn't define SFTPServerForUnixConchUser'") % (unix, )) unix = None else: class FileTransferForTestAvatar(unix.SFTPServerForUnixConchUser): def gotVersion(self, version, otherExt): return {b'conchTest': b'ext data'} def extendedRequest(self, extName, extData): if extName == b'testExtendedRequest': return b'bar' raise NotImplementedError components.registerAdapter(FileTransferForTestAvatar, TestAvatar, filetransfer.ISFTPServer) class SFTPTestBase(unittest.TestCase): def setUp(self): self.testDir = FilePath(self.mktemp()) # Give the testDir another level so we can safely "cd .." from it in # tests. self.testDir = self.testDir.child('extra') self.testDir.child('testDirectory').makedirs(True) with self.testDir.child('testfile1').open(mode='wb') as f: f.write(b'a' * 10 + b'b' * 10) with open('/dev/urandom', 'rb') as f2: f.write(f2.read(1024 * 64)) # random data self.testDir.child('testfile1').chmod(0o644)
self.builder = None self.properites = {} def getBuilder(self): return self.builder class FakeBuildStatusProperties(components.Adapter): def getProperty(self, name, default): return self.original.properties.get(name, default) def render(self, value): return "rndr(%s)" % (value, ) components.registerAdapter(FakeBuildStatusProperties, FakeBuildStatus, IProperties) class TestMailNotifier(unittest.TestCase): def test_createEmail_message_without_patch_and_log_contains_unicode(self): builds = [FakeBuildStatus(name="build")] msgdict = create_msgdict() mn = MailNotifier('*****@*****.**') m = mn.createEmail(msgdict, u'builder-n\u00E5me', u'project-n\u00E5me', SUCCESS, builds) try: m.as_string() except UnicodeEncodeError: self.fail('Failed to call as_string() on email message.') def test_createEmail_extraHeaders_one_build(self):
def testAdapterWithCmp(self): # Make sure that a __cmp__ on an adapter doesn't break anything components.registerAdapter(DoubleXAdapter, IAttrX, IAttrXX) xx = IAttrXX(Xcellent()) self.assertEqual(('x!', 'x!'), xx.xx())
"""Adds a notifier. Should this in the one of the Controller interfaces? """ n = results.INotifierChild(reference) return self.service.addNotifier(n) def checkReturns(self, rlist): for r in rlist: if isinstance(r, (Failure, Exception)): rlist[rlist.index(r)] = pickle.dumps(r, 2) return rlist components.registerAdapter(PBControllerRootFromService, cs.ControllerService, IPBController) class IPBControllerFactory(Interface): pass def PBServerFactoryFromService(service): """Adapt a ControllerService to a PBServerFactory. Is there a reason this is a function rather than a class? """ return pb.PBServerFactory(IPBController(service))
if parsed_url.query: qs.extend([parsed_url.query, '&']) qs.append(urlencode(params, doseq=True)) return urlunparse((parsed_url[0], parsed_url[1], parsed_url[2], parsed_url[3], ''.join(qs), parsed_url[5])) def _from_bytes(orig_bytes): return FileBodyProducer(StringIO(orig_bytes)) def _from_file(orig_file): return FileBodyProducer(orig_file) def _guess_content_type(filename): if filename: guessed = mimetypes.guess_type(filename)[0] else: guessed = None return guessed or 'application/octet-stream' registerAdapter(_from_bytes, str, IBodyProducer) registerAdapter(_from_file, file, IBodyProducer) registerAdapter(_from_file, StringIO, IBodyProducer) registerAdapter(_from_file, BytesIO, IBodyProducer)
self.child_getAllPendingResults = HTTPMultiEngineGetAllPendingResults( self.smultiengine) self.child_registerClient = HTTPMultiEngineRegisterClient( self.smultiengine) self.child_unregisterClient = HTTPMultiEngineUnregisterClient( self.smultiengine) #def locateChild(self, request, segments): # log.msg("Segments: " + repr(segments)) # return self, () def renderHTTP(self, request): return http.Response(200, stream=stream.MemoryStream(repr(request))) components.registerAdapter(HTTPMultiEngineRoot, IMultiEngine, IHTTPMultiEngineRoot) class HTTPMultiEngineBaseMethod(resource.Resource): def __init__(self, smultiengine): self.smultiengine = smultiengine log.msg("Creating child resource...") def locateChild(self, request, segments): return self, () def renderHTTP(self, request): return http.Response(200, stream=stream.MemoryStream(repr(request))) def parseTargets(self, targets): if targets == 'all':
class IPBTaskControllerFactory(Interface): pass def PBServerFactoryFromTaskController(taskController): #### TODO: Real authentication here portal = Portal(IPythonRealm(taskController)) checker = InMemoryUsernamePasswordDatabaseDontUse() checker.addUser("guest", "guest") portal.registerChecker(checker) return pb.PBServerFactory(portal) components.registerAdapter(PBTaskControllerFromTaskController, Task.TaskController, IPBTaskController) components.registerAdapter(PBServerFactoryFromTaskController, Task.TaskController, IPBTaskControllerFactory) #------------------------------------------------------------------------------- # CLIENT CLASSES #------------------------------------------------------------------------------- class PBTaskClient(object): """ XMLRPC based TaskController client that implements ITaskController. """ implements(Task.ITaskController) def __init__(self, perspective): self.perspective = perspective
raise ValueError("Unexpected return value: %r" % (result, )) # Unfortunately Klein imposes this strange requirement that the request object # be adaptable to KleinRequest. Klein only registers an adapter from # twisted.web.server.Request - despite the fact that the adapter doesn't # actually use the adaptee for anything. # # Here, register an adapter from the dummy request type so that tests can # exercise Klein-based code without trying to use the real request type. # # See https://github.com/twisted/klein/issues/31 from twisted.python.components import registerAdapter from klein.app import KleinRequest from klein.interfaces import IKleinRequest registerAdapter(KleinRequest, _DummyRequest, IKleinRequest) def build_schema_test(name, schema, schema_store, failing_instances, passing_instances): """ Create test case verifying that various instances pass and fail verification with a given JSON Schema. :param bytes name: Name of test case to create. :param dict schema: Schema to test. :param dict schema_store: The schema definitions. :param list failing_instances: Instances which should fail validation. :param list passing_instances: Instances which should pass validation. :returns: The test case; a ``SynchronousTestCase`` subclass.
def _from_bytes(orig_bytes): return FileBodyProducer(BytesIO(orig_bytes)) def _from_file(orig_file): return FileBodyProducer(orig_file) def _guess_content_type(filename): if filename: guessed = mimetypes.guess_type(filename)[0] else: guessed = None return guessed or 'application/octet-stream' registerAdapter(_from_bytes, bytes, IBodyProducer) registerAdapter(_from_file, BytesIO, IBodyProducer) if not _PY3: from StringIO import StringIO registerAdapter(_from_file, StringIO, IBodyProducer) # Suppress lint failure on Python 3. registerAdapter(_from_file, file, IBodyProducer) # noqa: F821 else: import io # file()/open() equiv on Py3 registerAdapter(_from_file, io.BufferedReader, IBodyProducer)
class JSONResponse(Response): """ JSON L{Response} object. Renders itself as an JSON document. """ def __init__(self, code, jobj, contentType="application/json", pretty=False): """ @param jobj: a Python object that can be serialized to JSON. """ kwargs = {} if pretty: kwargs["indent"] = 2 kwargs["separators"] = (',', ':') Response.__init__(self, code, stream=json.dumps(jobj, **kwargs)) self.headers.setHeader("content-type", http_headers.MimeType(*contentType.split("/"))) components.registerAdapter(Response, int, iweb.IResponse) __all__ = [ 'HTTPError', 'NotModifiedResponse', 'Request', 'Response', 'StatusResponse', 'RedirectResponse', 'checkIfRange', 'checkPreconditions', 'defaultPortForScheme', 'parseVersion', 'splitHostPort', "XMLResponse", "JSONResponse" ]
raise RuntimeError('not getting a command') def eofReceived(self): """ Note that EOF has been received. """ self.gotEOF = True def closed(self): """ Note that close has been received. """ self.gotClosed = True components.registerAdapter(StubSessionForStubAvatar, StubAvatar, session.ISession) class MockProcessProtocol(protocol.ProcessProtocol): """ A mock ProcessProtocol which echoes back data sent to it and appends a tilde. The tilde is appended so the tests can verify that we received and processed the data. @ivar packetData: C{str} of data to be sent when the connection is made. @ivar data: a C{str} of data received. @ivar err: a C{str} of error data received. @ivar inConnectionOpen: True if the input side is open. @ivar outConnectionOpen: True if the output side is open. @ivar errConnectionOpen: True if the error side is open. @ivar ended: False if the protocol has not ended, a C{Failure} if the
from xmantissa.test.test_website import SiteTestsMixin class TestAppElement(Element): """ View class for TestAppPowerup. """ docFactory = object() # masquerade as a valid Element, for the # purposes of theme lookup. def __init__(self, original): self.original = original Element.__init__(self) registerAdapter(TestAppElement, ITest, INavigableFragment) class FakeTheme(object): """ Trivial implementation of L{ITemplateNameResolver} which returns document factories from an in-memory dictionary. @ivar docFactories: C{dict} mapping fragment names to document factory objects. """ def __init__(self, docFactories): self.docFactories = docFactories def getDocFactory(self, fragmentName, default=None): """ Return the document factory for the given name, or the default value if
if self.locks: log.msg("releaseLocks(%s): %s" % (self, self.locks)) for lock, access in self.locks: if lock.isOwner(self, access): lock.release(self, access) else: # This should only happen if we've been interrupted assert self.stopped def getSummaryStatistic(self, name, summary_fn, initial_value=_sentinel): step_stats_list = [ st.getStatistic(name) for st in self.executedSteps if st.hasStatistic(name) ] if initial_value is self._sentinel: return reduce(summary_fn, step_stats_list) else: return reduce(summary_fn, step_stats_list, initial_value) # IBuildControl def getStatus(self): return self.build_status # stopBuild is defined earlier components.registerAdapter( lambda build: interfaces.IProperties(build.build_status), Build, interfaces.IProperties)