def _entityCreationTest(self, kind):
# Kind is "user" or "group"
realm = service.InMemoryWordsRealm("realmname")
name = "test" + kind.lower()
create = getattr(realm, "create" + kind.title())
get = getattr(realm, "get" + kind.title())
flag = "create" + kind.title() + "OnRequest"
dupExc = getattr(ewords, "Duplicate" + kind.title())
noSuchExc = getattr(ewords, "NoSuch" + kind.title())
# Creating should succeed
p = self.successResultOf(create(name))
self.assertEqual(name, p.name)
# Creating the same user again should not
self.failureResultOf(create(name)).trap(dupExc)
# Getting a non-existent user should succeed if createUserOnRequest is True
setattr(realm, flag, True)
p = self.successResultOf(get("new" + kind.lower()))
self.assertEqual("new" + kind.lower(), p.name)
# Getting that user again should return the same object
newp = self.successResultOf(get("new" + kind.lower()))
self.assertIdentical(p, newp)
# Getting a non-existent user should fail if createUserOnRequest is False
setattr(realm, flag, False)
self.failureResultOf(get("another" + kind.lower())).trap(noSuchExc)
def testGroupAddition(self):
realm = service.InMemoryWordsRealm("realmname")
p = service.Group("testgroup")
self.successResultOf(realm.addGroup(p))
group = self.successResultOf(realm.getGroup("testGroup"))
self.assertIdentical(p, group)
def testGroupUsernameCollision(self):
"""
Try creating a group with the same name as an existing user and
assert that it succeeds, since users and groups should not be in the
same namespace and collisions should be impossible.
"""
realm = service.InMemoryWordsRealm("realmname")
self.successResultOf(realm.createUser("test"))
self.successResultOf(realm.createGroup("test"))
def testGroupRetrieval(self):
realm = service.InMemoryWordsRealm("realmname")
group = self.successResultOf(realm.createGroup("testgroup"))
retrieved = self.successResultOf(realm.getGroup("testgroup"))
self.assertIdentical(group, retrieved)
(self.failureResultOf(realm.getGroup("nosuchgroup")).trap(ewords.NoSuchGroup))
def setUp(self):
self.realm = service.InMemoryWordsRealm("realmname")
self.checker = checkers.InMemoryUsernamePasswordDatabaseDontUse()
self.portal = portal.Portal(self.realm, [self.checker])
self.factory = service.IRCFactory(self.realm, self.portal)
c = []
for nick in self.STATIC_USERS:
c.append(self.realm.createUser(nick))
self.checker.addUser(nick.encode('ascii'), nick + "_password")
return DeferredList(c)
def testEnumeration(self):
realm = service.InMemoryWordsRealm("realmname")
self.successResultOf(realm.createGroup("groupone"))
self.successResultOf(realm.createGroup("grouptwo"))
groups = self.successResultOf(realm.itergroups())
n = [g.name for g in groups]
n.sort()
self.assertEqual(n, ["groupone", "grouptwo"])
def testGroupAddition(self):
realm = service.InMemoryWordsRealm("realmname")
p = service.Group("testgroup")
d = wFD(realm.addGroup(p))
yield d
d.getResult()
d = wFD(realm.getGroup(u"testGroup"))
yield d
group = d.getResult()
self.assertIdentical(p, group)
def setUp(self):
self.realm = service.InMemoryWordsRealm("realmname")
self.checker = checkers.InMemoryUsernamePasswordDatabaseDontUse()
self.portal = portal.Portal(self.realm, [self.checker])
self.factory = service.IRCFactory(self.realm, self.portal)
c = []
for nick in self.STATIC_USERS:
if isinstance(nick, bytes):
nick = nick.decode("utf-8")
c.append(self.realm.createUser(nick))
self.checker.addUser(nick, nick + u"_password")
return DeferredList(c)
def setUp(self):
self.realm = service.InMemoryWordsRealm("realmname")
self.checker = checkers.InMemoryUsernamePasswordDatabaseDontUse()
self.portal = portal.Portal(self.realm, [self.checker])
self.serverFactory = pb.PBServerFactory(self.portal)
self.serverFactory.protocol = self._protocolFactory
self.serverFactory.unsafeTracebacks = True
self.clientFactory = pb.PBClientFactory()
self.clientFactory.unsafeTracebacks = True
self.serverPort = reactor.listenTCP(0, self.serverFactory)
self.clientConn = reactor.connectTCP("127.0.0.1",
self.serverPort.getHost().port,
self.clientFactory)
def main():
log.startLogging(sys.stdout)
wordsRealm = service.InMemoryWordsRealm('twisted-playground.org')
wordsRealm.createGroupOnRequest = True
checker = checkers.InMemoryUsernamePasswordDatabaseDontUse(admin='admin')
ircPortal = portal.Portal(wordsRealm, [checker])
factory = service.IRCFactory(wordsRealm, ircPortal)
reactor.listenTCP(6666, factory)
reactor.run()
def testUserAddition(self):
realm = service.InMemoryWordsRealm("realmname")
# Create and manually add a user to the realm
p = service.User("testuser")
user = self.successResultOf(realm.addUser(p))
self.assertIdentical(p, user)
# Make sure getting that user returns the same object
retrieved = self.successResultOf(realm.getUser("testuser"))
self.assertIdentical(user, retrieved)
# Make sure looking up that user returns the same object
lookedUp = self.successResultOf(realm.lookupUser("testuser"))
self.assertIdentical(retrieved, lookedUp)
def testGroupRetrieval(self):
realm = service.InMemoryWordsRealm("realmname")
d = wFD(realm.createGroup(u"testgroup"))
yield d
group = d.getResult()
d = wFD(realm.getGroup(u"testgroup"))
yield d
retrieved = d.getResult()
self.assertIdentical(group, retrieved)
d = wFD(realm.getGroup(u"nosuchgroup"))
yield d
self.assertRaises(ewords.NoSuchGroup, d.getResult)
def testUserRetrieval(self):
realm = service.InMemoryWordsRealm("realmname")
# Make a user to play around with
user = self.successResultOf(realm.createUser("testuser"))
# Make sure getting the user returns the same object
retrieved = self.successResultOf(realm.getUser("testuser"))
self.assertIdentical(user, retrieved)
# Make sure looking up the user also returns the same object
lookedUp = self.successResultOf(realm.lookupUser("testuser"))
self.assertIdentical(retrieved, lookedUp)
# Make sure looking up a user who does not exist fails
(self.failureResultOf(realm.lookupUser("nosuchuser")).trap(ewords.NoSuchUser))
def testEnumeration(self):
realm = service.InMemoryWordsRealm("realmname")
d = wFD(realm.createGroup(u"groupone"))
yield d
d.getResult()
d = wFD(realm.createGroup(u"grouptwo"))
yield d
d.getResult()
groups = wFD(realm.itergroups())
yield groups
groups = groups.getResult()
n = [g.name for g in groups]
n.sort()
self.assertEqual(n, ["groupone", "grouptwo"])
def makeService(config):
credCheckers = config.get('credCheckers', [])
wordsRealm = service.InMemoryWordsRealm(config['hostname'])
wordsPortal = portal.Portal(wordsRealm, credCheckers)
msvc = MultiService()
# XXX Attribute lookup on config is kind of bad - hrm.
for plgName in config.interfacePlugins:
port = config.get(plgName + '-port')
if port is not None:
factory = config.interfacePlugins[plgName].getFactory(wordsRealm, wordsPortal)
svc = strports.service(port, factory)
svc.setServiceParent(msvc)
# This is bogus. createGroup is async. makeService must be
# allowed to return a Deferred or some crap.
for g in config['groups']:
wordsRealm.createGroup(g)
return msvc
def _entityCreationTest(self, kind):
# Kind is "user" or "group"
realm = service.InMemoryWordsRealm("realmname")
name = u'test' + kind.lower()
create = getattr(realm, 'create' + kind.title())
get = getattr(realm, 'get' + kind.title())
flag = 'create' + kind.title() + 'OnRequest'
dupExc = getattr(ewords, 'Duplicate' + kind.title())
noSuchExc = getattr(ewords, 'NoSuch' + kind.title())
# Creating should succeed
d = wFD(create(name))
yield d
p = d.getResult()
self.assertEqual(p.name, name)
# Creating the same user again should not
d = wFD(create(name))
yield d
self.assertRaises(dupExc, d.getResult)
# Getting a non-existent user should succeed if createUserOnRequest is True
setattr(realm, flag, True)
d = wFD(get(u"new" + kind.lower()))
yield d
p = d.getResult()
self.assertEqual(p.name, "new" + kind.lower())
# Getting that user again should return the same object
d = wFD(get(u"new" + kind.lower()))
yield d
newp = d.getResult()
self.assertIdentical(p, newp)
# Getting a non-existent user should fail if createUserOnRequest is False
setattr(realm, flag, False)
d = wFD(get(u"another" + kind.lower()))
yield d
self.assertRaises(noSuchExc, d.getResult)
def testUserRetrieval(self):
realm = service.InMemoryWordsRealm("realmname")
# Make a user to play around with
d = wFD(realm.createUser(u"testuser"))
yield d
user = d.getResult()
# Make sure getting the user returns the same object
d = wFD(realm.getUser(u"testuser"))
yield d
retrieved = d.getResult()
self.assertIdentical(user, retrieved)
# Make sure looking up the user also returns the same object
d = wFD(realm.lookupUser(u"testuser"))
yield d
lookedUp = d.getResult()
self.assertIdentical(retrieved, lookedUp)
# Make sure looking up a user who does not exist fails
d = wFD(realm.lookupUser(u"nosuchuser"))
yield d
self.assertRaises(ewords.NoSuchUser, d.getResult)
# Last updated: 2013.01.27
# This code is in the public domain
#-------------------------------------------------------------------------------
import sys
from twisted.cred import checkers, portal
from twisted.internet import reactor
from twisted.internet.endpoints import TCP4ServerEndpoint
from twisted.python import log
from twisted.words import service
ROOM = 'room'
USERS = dict(user1='pass1', user2='pass2', user3='pass3', user4='pass4')
if __name__ == '__main__':
log.startLogging(sys.stdout)
# Initialize the Cred authentication system used by the IRC server.
realm = service.InMemoryWordsRealm('testrealm')
realm.addGroup(service.Group(ROOM))
user_db = checkers.InMemoryUsernamePasswordDatabaseDontUse(**USERS)
portal = portal.Portal(realm, [user_db])
# IRC server factory.
ircfactory = service.IRCFactory(realm, portal)
# Connect a server to the TCP port 6667 endpoint and start listening.
endpoint = TCP4ServerEndpoint(reactor, 6667)
endpoint.listen(ircfactory)
reactor.run()
def __init__(self):
realm = service.InMemoryWordsRealm("TEST")
realm.createGroupOnRequest = True
realm.createUserOnRequest = True
port = portal.Portal(realm, [SimpleChecker()])
service.IRCFactory.__init__(self, realm, port)
rooms = {}
irc_users = {}
if path.exists(path.expanduser('~') + '/.luckystrike/config.json'):
with open(path.expanduser('~') + '/.luckystrike/config.json') as config_file:
configuration = dict(json.loads(config_file.read()))
else:
with open('config.json') as config_file:
configuration = dict(json.loads(config_file.read()))
users = configuration['users']
parser = argparse.ArgumentParser(description='Campfire to IRC Proxy')
parser.add_argument(
'-d', '--debug',
action='count',
help='add debug logging, add multiple times to increase level'
)
parser.add_argument(
'-s', '--setup_config',
action='store_true',
help='generate config.json'
)
args = parser.parse_args()
# connect to Campfire
campfire = pinder.Campfire(configuration['domain'], configuration['api_key'])
# Initialize the Cred authentication system used by the IRC server.
irc_realm = service.InMemoryWordsRealm('LuckyStrike')
from twisted.cred import checkers, portal
from twisted.internet import reactor
from twisted.words import service
wordsRealm = service.InMemoryWordsRealm("example.com")
wordsRealm.createGroupOnRequest = True
checker = checkers.FilePasswordDB("passwords.txt")
portal = portal.Portal(wordsRealm, [checker])
reactor.listenTCP(6667, service.IRCFactory(wordsRealm, portal))
reactor.run()
