def test_listTwoFactories(self): """ I{axiomatic port list} displays two different factories separately from each other. """ store = Store() factoryOne = DummyFactory(store=store) factoryTwo = DummyFactory(store=store) portOne = TCPPort(store=store, factory=factoryOne, portNumber=10, interface=u"foo") portTwo = TCPPort(store=store, factory=factoryTwo, portNumber=20, interface=u"bar") self.assertSuccessStatus(self._makeConfig(store), ["list"]) self.assertEqual( "%d) %r listening on:\n" % (factoryOne.storeID, factoryOne) + " %d) TCP, interface %s, port %d\n" % (portOne.storeID, portOne.interface, portOne.portNumber) + "%d) %r listening on:\n" % (factoryTwo.storeID, factoryTwo) + " %d) TCP, interface %s, port %d\n" % (portTwo.storeID, portTwo.interface, portTwo.portNumber), sys.stdout.getvalue())
def test_deletePorts(self): """ I{axiomatic port delete} deletes each ports with a C{storeID} which is specified. """ store = Store(filesdir=self.mktemp()) factory = DummyFactory(store=store) deleteTCP = TCPPort( store=store, factory=factory, portNumber=10, interface=u"foo") keepTCP = TCPPort( store=store, factory=factory, portNumber=10, interface=u"bar") deleteSSL = SSLPort( store=store, factory=factory, portNumber=10, interface=u"baz", certificatePath=store.filesdir.child("baz")) keepSSL = SSLPort( store=store, factory=factory, portNumber=10, interface=u"quux", certificatePath=store.filesdir.child("quux")) deleteEndpoint = StringEndpointPort( store=store, factory=factory, description=u'tcp:1234') keepEndpoint = StringEndpointPort( store=store, factory=factory, description=u'tcp:1235') self.assertSuccessStatus( self._makeConfig(store), ["delete", "--port-identifier", str(deleteTCP.storeID), "--port-identifier", str(deleteSSL.storeID), "--port-identifier", str(deleteEndpoint.storeID)]) self.assertEqual("Deleted.\n", sys.stdout.getvalue()) self.assertEqual(list(store.query(TCPPort)), [keepTCP]) self.assertEqual(list(store.query(SSLPort)), [keepSSL]) self.assertEqual(list(store.query(StringEndpointPort)), [keepEndpoint])
def installSite(self, siteStore, domain, publicURL, generateCert=True): """ Create the necessary items to run an HTTP server and an SSH server. """ certPath = siteStore.filesdir.child("server.pem") if generateCert and not certPath.exists(): certPath.setContent(self._createCert(domain, genSerial())) # Install the base Mantissa offering. IOfferingTechnician(siteStore).installOffering(baseOffering) # Make the HTTP server baseOffering includes listen somewhere. site = siteStore.findUnique(SiteConfiguration) site.hostname = domain installOn(TCPPort(store=siteStore, factory=site, portNumber=8080), siteStore) installOn( SSLPort(store=siteStore, factory=site, portNumber=8443, certificatePath=certPath), siteStore) # Make the SSH server baseOffering includes listen somewhere. shell = siteStore.findUnique(SecureShellConfiguration) installOn(TCPPort(store=siteStore, factory=shell, portNumber=8022), siteStore) # Install a front page on the top level store so that the # developer will have something to look at when they start up # the server. fp = siteStore.findOrCreate(publicweb.FrontPage, prefixURL=u'') installOn(fp, siteStore)
def pop3listener2to3(oldPOP3): """ Create TCPPort and SSLPort items as appropriate. """ newPOP3 = oldPOP3.upgradeVersion(POP3Listener.typeName, 2, 3, userbase=oldPOP3.userbase, certificateFile=oldPOP3.certificateFile) if oldPOP3.portNumber is not None: port = TCPPort(store=newPOP3.store, portNumber=oldPOP3.portNumber, factory=newPOP3) installOn(port, newPOP3.store) securePortNumber = oldPOP3.securePortNumber certificateFile = oldPOP3.certificateFile if securePortNumber is not None and certificateFile: oldCertPath = newPOP3.store.dbdir.preauthChild(certificateFile) if oldCertPath.exists(): newCertPath = newPOP3.store.newFilePath('pop3.pem') oldCertPath.copyTo(newCertPath) port = SSLPort(store=newPOP3.store, portNumber=oldPOP3.securePortNumber, certificatePath=newCertPath, factory=newPOP3) installOn(port, newPOP3.store) newPOP3.store.powerDown(newPOP3, IService) return newPOP3
def createPort(self, portNumber, ssl, certPath, factory, interface=u''): """ Create a new listening port. @type portNumber: C{int} @param portNumber: Port number on which to listen. @type ssl: C{bool} @param ssl: Indicates whether this should be an SSL port or not. @type certPath: C{str} @param ssl: If C{ssl} is true, a path to a certificate file somewhere within the site store's files directory. Ignored otherwise. @param factory: L{Item} which provides L{IProtocolFactoryFactory} which will be used to get a protocol factory to associate with this port. @return: C{None} """ store = self.store.parent if ssl: port = SSLPort(store=store, portNumber=portNumber, certificatePath=FilePath(certPath), factory=factory, interface=interface) else: port = TCPPort(store=store, portNumber=portNumber, factory=factory, interface=interface) installOn(port, store)
def test_rootURLNonstandardRequestPort(self): """ L{SiteConfiguration.rootURL} returns C{/} for a request made onto a non-standard port which is one on which the L{SiteConfiguration} is configured to listen. """ request = FakeRequest( headers={'host': '%s:%s' % (self.domain.encode('ascii'), 54321)}) TCPPort(store=self.store, factory=self.site, portNumber=54321) self.assertEqual(self.site.rootURL(request), URL('', ''))
def test_listTwoPorts(self): """ I{axiomatic port list} displays two different ports bound to the same factory together beneath that factory. """ store = Store() factory = DummyFactory(store=store) portOne = TCPPort( store=store, factory=factory, portNumber=1234, interface=u"foo") portTwo = TCPPort( store=store, factory=factory, portNumber=2345, interface=u"bar") self.assertSuccessStatus(self._makeConfig(store), ["list"]) self.assertEqual( "%d) %r listening on:\n" % (factory.storeID, factory) + " %d) TCP, interface %s, port %d\n" % ( portOne.storeID, portOne.interface, portOne.portNumber) + " %d) TCP, interface %s, port %d\n" % ( portTwo.storeID, portTwo.interface, portTwo.portNumber), sys.stdout.getvalue())
def setUp(self): """ Create a L{Store}, L{WebSite} and necessary request-related objects to test L{LoginPage}. """ self.siteStore = Store(filesdir=self.mktemp()) Mantissa().installSite(self.siteStore, self.domain, u"", False) self.site = self.siteStore.findUnique(SiteConfiguration) installOn( TCPPort(store=self.siteStore, factory=self.site, portNumber=80), self.siteStore) self.context = WebContext() self.request = FakeRequest() self.context.remember(self.request)
def test_listAnyInterface(self): """ I{axiomatic port list} displays a special string for a port bound to C{INADDR_ANY}. """ store = Store() factory = DummyFactory(store=store) port = TCPPort( store=store, factory=factory, portNumber=1234, interface=u"") self.assertSuccessStatus(self._makeConfig(store), ["list"]) self.assertEqual( "%d) %r listening on:\n" % (factory.storeID, factory) + " %d) TCP, any interface, port %d\n" % (port.storeID, port.portNumber), sys.stdout.getvalue())
def test_createNonFactoryIdentifier(self): """ If a storeID which is associated with an item which does not provide L{IProtocolFactoryFactory} is given for the C{factory-identifier} option of I{axiomatic port create}, a short error is written to standard output. """ store = Store() storeID = TCPPort(store=store).storeID self.assertFailStatus(1, self._makeConfig(store), [ "create", "--strport", "tcp:8080", "--factory-identifier", str(storeID) ]) self.assertEqual("%d does not identify a factory.\n" % (storeID, ), sys.stdout.getvalue())
def test_listTCPPort(self): """ When I{axiomatic port list} is invoked for a L{Store} which has a L{TCPPort} in it, the details of that port, including its factory, are written to stdout. """ store = Store() factory = DummyFactory(store=store) port = TCPPort( store=store, factory=factory, portNumber=1234, interface=u"foo") self.assertSuccessStatus(self._makeConfig(store), ["list"]) self.assertEqual( "%d) %r listening on:\n" % (factory.storeID, factory) + " %d) TCP, interface %s, port %d\n" % ( port.storeID, port.interface, port.portNumber), sys.stdout.getvalue())
def createDatabase(siteStore): """ Populate the given Store with a TCPPort and SSLPort. """ factory = WebSite(store=siteStore) installOn(factory, siteStore) installOn(TCPPort(store=siteStore, portNumber=TCP_PORT, factory=factory), siteStore) certificatePath = siteStore.newFilePath('certificate') key = KeyPair.generate() cert = key.selfSignedCert(1) certificatePath.setContent( cert.dump(FILETYPE_PEM) + key.dump(FILETYPE_PEM)) installOn( SSLPort(store=siteStore, portNumber=SSL_PORT, certificatePath=certificatePath, factory=factory), siteStore)
def test_cannotDeleteOtherStuff(self): """ I{axiomatic port delete} will not delete something which is neither a L{TCPPort} nor an L{SSLPort} and does not delete anything if an invalid port identifier is present in the command. """ store = Store() factory = DummyFactory(store=store) tcp = TCPPort( store=store, factory=factory, interface=u"foo", portNumber=1234) self.assertFailStatus( 1, self._makeConfig(store), ["delete", "--port-identifier", str(tcp.storeID), "--port-identifier", str(factory.storeID)]) self.assertEqual( "%d does not identify a port.\n" % (factory.storeID,), sys.stdout.getvalue()) self.assertEqual(list(store.query(DummyFactory)), [factory]) self.assertEqual(list(store.query(TCPPort)), [tcp])
def upgradeMailTransferAgent3to4(oldMTA): """ Create TCPPort and SSLPort items as appropriate. """ if isinstance(oldMTA, MailDeliveryAgent): return oldMTA newMTA = oldMTA.upgradeVersion(MailTransferAgent.typeName, 3, 4, userbase=oldMTA.userbase, certificateFile=oldMTA.certificateFile, messageCount=oldMTA.messageCount, domain=oldMTA.domain) if oldMTA.portNumber is not None: port = TCPPort(store=newMTA.store, portNumber=oldMTA.portNumber, factory=newMTA) installOn(port, newMTA.store) securePortNumber = oldMTA.securePortNumber certificateFile = oldMTA.certificateFile if securePortNumber is not None and certificateFile: oldCertPath = newMTA.store.dbdir.preauthChild(certificateFile) if oldCertPath.exists(): newCertPath = newMTA.store.newFilePath('mta.pem') oldCertPath.copyTo(newCertPath) port = SSLPort(store=newMTA.store, portNumber=securePortNumber, certificatePath=newCertPath, factory=newMTA) installOn(port, newMTA.store) newMTA.store.powerDown(newMTA, IService) return newMTA
def _makeSiteConfiguration(currentVersion, oldSite, couldHavePorts): from xmantissa.publicweb import AnonymousSite newSite = oldSite.upgradeVersion( 'mantissa_web_powerup', currentVersion, 6, hitCount=oldSite.hitCount) if newSite.store.parent is not None: return newSite # SiteConfiguration dependsOn LoginSystem. LoginSystem was probably # installed by the mantissa axiomatic command. During the dependency # system conversion, that command was changed to use installOn on the # LoginSystem. However, no upgrader was supplied to create the new # dependency state. Consequently, there may be none. Consequently, a new # LoginSystem will be created if an item which dependsOn LoginSystem is # installed. This would be bad. So, set up the necessary dependency state # here, before instantiating SiteConfiguration. -exarkun # Addendum: it is almost certainly the case that there are not legitimate # configurations which lack a LoginSystem. However, a large number of # database upgrade tests construct unrealistic databases. One aspect of # the unrealism is that they lack a LoginSystem. Therefore, rather than # changing all the bogus stubs and regenerating the stubs, I will just # support the case where LoginSystem is missing. However, note that a # LoginSystem upgrader may invalidate this check and result in a duplicate # being created anyway. -exarkun loginSystem = oldSite.store.findUnique(LoginSystem, default=None) if loginSystem is not None and installedOn(loginSystem) is None: installOn(loginSystem, oldSite.store) uninstallFrom(oldSite.store, oldSite) site = SiteConfiguration( store=oldSite.store, httpLog=oldSite.store.filesdir.child('httpd.log'), hostname=getattr(oldSite, "hostname", None) or u"localhost") installOn(site, site.store) anonymousAvatar = AnonymousSite(store=oldSite.store) installOn(anonymousAvatar, oldSite.store) if couldHavePorts: for tcp in site.store.query(TCPPort, TCPPort.factory == oldSite): tcp.factory = site for ssl in site.store.query(SSLPort, SSLPort.factory == oldSite): ssl.factory = site else: if oldSite.portNumber is not None: port = TCPPort( store=oldSite.store, portNumber=oldSite.portNumber, factory=site) installOn(port, oldSite.store) securePortNumber = oldSite.securePortNumber certificateFile = oldSite.certificateFile if securePortNumber is not None and certificateFile: oldCertPath = site.store.dbdir.preauthChild(certificateFile) newCertPath = site.store.newFilePath('server.pem') oldCertPath.moveTo(newCertPath) port = SSLPort( store=site.store, portNumber=oldSite.securePortNumber, certificatePath=newCertPath, factory=site) installOn(port, site.store) newSite.deleteFromStore()