Example #1
0
    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)
Example #2
0
def registerCustomFieldSerializer(serializerClass, typeClass):
    """Register a custom field serializer for a specific type.
    """
    registerAdapter(
        serializerClass, typeClass, igwt.ICustomFieldSerializer
        )
    registerTypeClass(typeClass)
Example #3
0
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()
Example #5
0
def check_config_base():
    from mypkg import config, interfaces, usesconfig

    components.registerAdapter(
        AdaptRunningConfigToMyConfig, config.MyConfig, IMyConfig)

    print usesconfig.do_a_config_thing()
Example #6
0
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))
Example #7
0
    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)
Example #9
0
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)
Example #12
0
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
Example #14
0
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)
Example #15
0
    def register():
        """Register this component
        """

        try:
            components.registerAdapter(MambaSQLAdapter, MySQL, IMambaSQL)
        except ValueError:
            # component already registered
            pass
Example #16
0
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)
Example #17
0
File: base.py Project: fanatic/code
    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()
Example #18
0
 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)
Example #19
0
 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
Example #20
0
 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)
Example #23
0
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()
Example #24
0
 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))
Example #25
0
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)
Example #26
0
 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
Example #27
0
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)
Example #31
0
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)

Example #32
0
        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)

Example #33
0
        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)
Example #34
0
        """


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)
Example #35
0

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.
Example #37
0
                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
Example #38
0
    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):
Example #39
0
            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
Example #40
0
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)
Example #41
0
        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
Example #42
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:
Example #43
0
        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
Example #44
0
    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])
Example #45
0
        # 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):
Example #46
0
        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)
Example #47
0
        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
Example #48
0
        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)
Example #49
0
        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):
Example #50
0
 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())
Example #51
0
        """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))
    
    
Example #52
0
    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':
Example #54
0

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
Example #55
0
        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.
Example #56
0

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)
Example #57
0
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"
]
Example #58
0
            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
Example #59
0
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
Example #60
0
        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)