def testReconnect(self):
disconnectDeferred = defer.Deferred()
reconnectDeferred = defer.Deferred()
def connected(_):
self.failUnless(a.planet is not None)
self.assertEqual(len(self.vishnu.adminHeaven.avatars), 1)
def _disconnected(_):
disconnectDeferred.callback(None)
def _connected(_):
map(a.disconnect, ids)
reconnectDeferred.callback(None)
ids = []
ids.append(a.connect('disconnected', _disconnected))
ids.append(a.connect('connected', _connected))
a.clientFactory.disconnect()
return disconnectDeferred
def disconnected(_):
return reconnectDeferred
def reconnected(_):
# yay
a.shutdown()
a = admin.AdminModel()
d = a.connectToManager(self.connectionInfo, writeConnection=False)
d.addCallback(connected)
d.addCallback(disconnected)
d.addCallback(reconnected)
return d
def testConnectSuccess(self):
def connected(_):
self.failUnless(a.planet is not None)
self.assertEqual(len(self.vishnu.adminHeaven.avatars), 1)
a.shutdown()
a = admin.AdminModel()
d = a.connectToManager(self.connectionInfo, writeConnection=False)
d.addCallback(connected)
return d
def connect(self, options):
# code from main.py in this directory
def _connectedCb(model):
self.model = model
self.debug('Connected to manager.')
planet = model.planet
components = planet.get('atmosphere').get('components')
for c in components:
ctype = c.get('type')
# check if this component is a bouncer
if 'bouncer' in ctype:
if c.get('name') == self.options.bouncer:
self.check_bouncer(c, ctype)
def _connectedEb(failure):
reactor.stop()
if failure.check(errors.ConnectionFailedError):
return self.unknown('Unable to connect to manager.')
if failure.check(errors.ConnectionRefusedError):
return self.critical('Manager refused connection.')
connection = connections.parsePBConnectionInfoRecent(
options.manager, options.transport == 'ssl')
# platform-3/trunk compatibility stuff
try:
# platform-3
self.adminModel = admin.AdminModel(connection.authenticator)
self.debug('code is platform-3')
d = self.adminModel.connectToHost(connection.host, \
connection.port, not connection.use_ssl)
except TypeError:
# trunk
self.adminModel = admin.AdminModel()
self.debug('code is trunk')
d = self.adminModel.connectToManager(connection)
except:
self.debug('error connecting with manager')
d.addCallback(_connectedCb)
d.addErrback(_connectedEb)
def __init__(self):
log.init()
self.medium = admin.AdminModel()
i = connection.PBConnectionInfo(
"127.0.0.1", 7531, True,
pb.Authenticator(username='******', password='******'))
d = self.medium.connectToManager(i)
d.addCallback(self.connected)
d.addErrback(twistedlog.err)
def connect(self, options):
connection = connections.parsePBConnectionInfoRecent(options.manager,
use_ssl=options.transport == 'ssl')
# platform-3/trunk compatibility stuff to guard against
# gratuitous changes
try:
# platform-3
self.medium = admin.AdminModel(connection.authenticator)
self.debug("code is platform-3")
except TypeError:
# trunk
self.medium = admin.AdminModel()
self.debug("code is trunk")
if hasattr(self.medium, 'connectToHost'):
# platform-3
d = self.medium.connectToHost(connection.host,
connection.port, not connection.use_ssl)
else:
d = self.medium.connectToManager(connection)
d.addCallback(self._connectedCb)
d.addErrback(self._connectedEb)
def connectToManager(self, connection):
"""
Connect to a manager.
@type connection: L{flumotion.common.connection.PBConnectionInfo}
@rtype: L{defer.Deferred} firing L{flumotion.admin.admin.AdminModel}
"""
from flumotion.twisted import pb as fpb
if not connection.authenticator:
connection.authenticator = fpb.Authenticator(
username=connection.username,
password=connection.password,
address=connection.host)
# platform-3/trunk compatibility stuff to guard against
# gratuitous changes
try:
# platform-3
adminMedium = admin.AdminModel(connection.authenticator)
self.debug("code is platform-3")
except TypeError:
# trunk
adminMedium = admin.AdminModel()
self.debug("code is trunk")
if hasattr(adminMedium, 'connectToHost'):
# platform-3
d = adminMedium.connectToHost(connection.host, connection.port,
not connection.use_ssl)
else:
d = adminMedium.connectToManager(connection)
d.addCallback(self._connectToManagerCb, adminMedium)
d.addErrback(self._connectToManagerEb)
return d
def testConnectFailure(self):
def connected(_):
self.fail('should not have connected')
def failure(f):
# ok!
a.shutdown()
a = admin.AdminModel()
# create a connectionInfo that will not succeed
i = connection.PBConnectionInfo(
self.connectionInfo.host, self.connectionInfo.port,
self.connectionInfo.use_ssl,
pb.Authenticator(username='******', password='******'))
d = a.connectToManager(i, writeConnection=False)
d.addCallbacks(connected, failure)
return d
class MultiAdminModel(log.Loggable):
logCategory = 'multiadmin'
def __init__(self):
self.admins = watched.WatchedDict() # {managerId: AdminModel}
self._listeners = []
self._reconnectHandlerIds = {} # managerId => [disconnect, id..]
self._startSet = startset.StartSet(self.admins.has_key,
errors.AlreadyConnectingError,
errors.AlreadyConnectedError)
# Listener implementation
def emit(self, signal_name, *args, **kwargs):
self.debug('emit %r %r %r' % (signal_name, args, kwargs))
assert signal_name != 'handler'
for c in self._listeners:
if getattr(c, 'model_handler', None):
c.model_handler(c, signal_name, *args, **kwargs)
elif getattr(c, 'model_%s' % signal_name):
getattr(c, 'model_%s' % signal_name)(*args, **kwargs)
else:
s = 'No model_%s in %r and no model_handler' % (signal_name, c)
raise NotImplementedError(s)
def addListener(self, obj):
assert not obj in self._listeners
self._listeners.append(obj)
def removeListener(self, obj):
self._listeners.remove(obj)
def _managerConnected(self, admin):
if admin.managerId not in self._reconnectHandlerIds:
# the first time a manager is connected to, start listening
# for reconnections; intertwingled with removeManager()
ids = []
ids.append(admin.connect('connected', self._managerConnected))
ids.append(admin.connect('disconnected',
self._managerDisconnected))
self._reconnectHandlerIds[admin.managerId] = admin, ids
adminplanet = admin.planet
self.info('Connected to manager %s (planet %s)', admin.managerId,
adminplanet.get('name'))
assert admin.managerId not in self.admins
self.admins[admin.managerId] = admin
self.emit('addPlanet', admin, adminplanet)
def _managerDisconnected(self, admin):
if admin.managerId in self.admins:
self.emit('removePlanet', admin, admin.planet)
del self.admins[admin.managerId]
else:
self.warning('Could not find admin model %r', admin)
def addManager(self,
connectionInfo,
tenacious=False,
writeConnection=True):
i = connectionInfo
managerId = str(i)
# This dance of deferreds is here so as to make sure that
# removeManager can cancel a pending connection.
# can raise errors.AlreadyConnectingError or
# errors.AlreadyConnectedError
try:
startD = self._startSet.createStart(managerId)
except Exception, e:
return defer.fail(e)
a = admin.AdminModel()
connectD = a.connectToManager(i,
tenacious,
writeConnection=writeConnection)
assert a.managerId == managerId
def connect_callback(_):
self._startSet.avatarStarted(managerId)
def connect_errback(failure):
self._startSet.avatarStopped(managerId, lambda _: failure)
connectD.addCallbacks(connect_callback, connect_errback)
def start_callback(_):
self._managerConnected(a)
def start_errback(failure):
a.shutdown()
return failure
startD.addCallbacks(start_callback, start_errback)
return startD
def testConstructor(self):
model = admin.AdminModel()