def testRenderHTTPAllowDefault(self):
streamer = FakeStreamer(mediumClass=FakeAuthFailingMedium)
httpauth = HTTPAuthentication(streamer)
resource = resources.HTTPStreamingResource(streamer, httpauth)
httpauth.setBouncerName('fakebouncer')
streamer.caps = True
self.failUnless(resource.isReady())
d = defer.Deferred()
def wrongToken(_):
request = FakeRequest(user='******')
return self.deferAssertUnauthorized(httpauth, request)
def errorDisallowDefault(_, error):
streamer.medium.failure = error
request = FakeRequest(user='******')
return self.deferAssertInternalServerError(httpauth, request)
def errorAllowDefault(_, error):
streamer.medium.failure = error
httpauth.setAllowDefault(True)
request = FakeRequest(user='******')
return self.deferAssertAuthorized(httpauth, request)
d.addCallback(wrongToken)
d.addCallback(errorDisallowDefault, errors.NotConnectedError())
d.addCallback(errorDisallowDefault, errors.UnknownComponentError())
d.addCallback(errorAllowDefault, errors.NotConnectedError())
d.addCallback(errorAllowDefault, errors.UnknownComponentError())
d.callback(None)
return d
def perspective_upstreamList(self, avatarId):
"""
List a component and its upstream components along with
types and worker hosts.
@param avatarId: the component avatar id
@type avatarId: str
"""
def get_eaters_ids(eaters_dic):
avatars = []
for flow in eaters_dic.keys():
comps = eaters_dic[flow]
for c in comps:
(name, what) = c[0].split(':')
avatars.append('/%s/%s' % (flow, name))
return avatars
def create_response(components, workers):
comps = []
for c in components:
workerName = c.get('workerName')
host = "unknown"
for w in workers:
if workerName == w.get('name'):
host = w.get('host')
break
comps.append((c.get('name'), c.get('type'), host))
return comps
component = util.findComponent(self.vishnu.state, avatarId)
if not component:
self.warning('No component with avatar id %s' % avatarId)
raise errors.UnknownComponentError(avatarId)
eaters = component.get('config').get('eater', {})
eaters_id = get_eaters_ids(eaters)
comps = [component]
while len(eaters_id) > 0:
eaters = {}
for i in eaters_id:
try:
compState = util.findComponent(self.vishnu.state, i)
comps.append(compState)
eaters.update(compState.get('config').get('eater', {}))
except Exception, e:
self.debug(log.getExceptionMessage(e))
emsg = "Error retrieving component '%s'" % i
raise errors.UnknownComponentError(emsg)
eaters_id = get_eaters_ids(eaters)
def perspective_keepAlive(self, bouncerName, issuerName, ttl):
"""
Resets the expiry timeout for keycards issued by issuerName. See
L{flumotion.component.bouncers.bouncer} for more information.
@since: 0.4.3
@param bouncerName: the name of the atmosphere bouncer, or None
@type bouncerName: str or None
@param issuerName: the issuer for which keycards should be kept
alive; that is to say, keycards with the
attribute 'issuerName' set to this value will
have their ttl values reset.
@type issuerName: str
@param ttl: the new expiry timeout
@type ttl: number
@returns: a deferred which will fire success or failure.
"""
self.debug('keycards keepAlive on behalf of %s, ttl=%d', issuerName,
ttl)
if not bouncerName:
return self.vishnu.bouncer.keepAlive(issuerName, ttl)
self.debug('looking for bouncer %s in atmosphere', bouncerName)
avatarId = common.componentId('atmosphere', bouncerName)
if not self.heaven.hasAvatar(avatarId):
self.warning('No bouncer with id %s registered', avatarId)
raise errors.UnknownComponentError(avatarId)
bouncerAvatar = self.heaven.getAvatar(avatarId)
return bouncerAvatar.keepAlive(issuerName, ttl)
def perspective_authenticate(self, bouncerName, keycard):
"""
Authenticate the given keycard.
If no bouncerName given, authenticate against the manager's bouncer.
If a bouncerName is given, authenticate against the given bouncer
in the atmosphere.
@since: 0.3.1
@param bouncerName: the name of the atmosphere bouncer, or None
@type bouncerName: str or None
@param keycard: the keycard to authenticate
@type keycard: L{flumotion.common.keycards.Keycard}
@returns: a deferred, returning the keycard or None.
"""
if not bouncerName:
self.debug(
'asked to authenticate keycard %r using manager bouncer' %
keycard)
return self.vishnu.bouncer.authenticate(keycard)
self.debug('asked to authenticate keycard %r using bouncer %s' %
(keycard, bouncerName))
avatarId = common.componentId('atmosphere', bouncerName)
if not self.heaven.hasAvatar(avatarId):
self.warning('No bouncer with id %s registered' % avatarId)
raise errors.UnknownComponentError(avatarId)
bouncerAvatar = self.heaven.getAvatar(avatarId)
return bouncerAvatar.authenticate(keycard)
def killJobByPid(self, pid, signum):
if pid not in self._jobInfos:
raise errors.UnknownComponentError(pid)
jobInfo = self._jobInfos[pid]
self.debug("Sending signal %d to job %s at pid %d", signum,
jobInfo.avatarId, jobInfo.pid)
signalPid(jobInfo.pid, signum)
def perspective_componentInvoke(self, avatarId, methodName,
*args, **kwargs):
"""
Call a remote method on the component.
@param avatarId: the component avatar id
@type avatarId: str
@param methodName: name of the method to call
@type methodName: str
"""
component = util.findComponent(self.vishnu.state, avatarId)
if not component:
self.warning('No component with avatar id %s' % avatarId)
raise errors.UnknownComponentError(avatarId)
return self.perspective_componentCallRemote(component, methodName,
*args, **kwargs)
def perspective_removeKeycardId(self, bouncerName, keycardId):
"""
Remove a keycard on the given bouncer on behalf of a
component's medium.
This is requested by a component that created the keycard.
@type bouncerName: str
@param keycardId: id of keycard to remove
@type keycardId: str
"""
avatarId = common.componentId('atmosphere', bouncerName)
if not self.heaven.hasAvatar(avatarId):
self.warning('No bouncer with id %s registered', avatarId)
raise errors.UnknownComponentError(avatarId)
return self.heaven.getAvatar(avatarId).removeKeycardId(keycardId)
def perspective_componentCallRemote(self, componentState, methodName,
*args, **kwargs):
"""
Call a method on the given component on behalf of an admin client.
@param componentState: state of the component to call the method on
@type componentState: L{planet.ManagerComponentState}
@param methodName: name of the method to call. Gets proxied to
L{flumotion.component.component.""" \
"""BaseComponentMedium}'s remote_(methodName)
@type methodName: str
@rtype: L{twisted.internet.defer.Deferred}
"""
assert isinstance(componentState, planet.ManagerComponentState), \
"%r is not a componentState" % componentState
if methodName == "start":
self.warning('forwarding "start" to perspective_componentStart')
return self.perspective_componentStart(componentState)
m = self.vishnu.getComponentMapper(componentState)
if not m:
self.warning('Component not mapped. Maybe deleted.')
raise errors.UnknownComponentError(componentState)
avatar = m.avatar
if not avatar:
self.warning('No avatar for %s, cannot call remote' %
componentState.get('name'))
raise errors.SleepingComponentError(componentState)
# XXX: Maybe we need to have a prefix, so we can limit what an
# admin interface can call on a component
try:
return avatar.mindCallRemote(methodName, *args, **kwargs)
except Exception, e:
msg = "exception on remote call %s: %s" % (methodName,
log.getExceptionMessage(e))
self.warning(msg)
raise errors.RemoteMethodError(methodName,
log.getExceptionMessage(e))
def perspective_expireKeycard(self, requesterId, keycardId):
"""
Expire a keycard (and thus the requester's connection)
issued to the given requester.
This is called by the bouncer component that authenticated the keycard.
@param requesterId: name (avatarId) of the component that originally
requested authentication for the given keycardId
@type requesterId: str
@param keycardId: id of keycard to expire
@type keycardId: str
"""
# FIXME: we should also be able to expire manager bouncer keycards
if not self.heaven.hasAvatar(requesterId):
self.warning(
'asked to expire keycard %s for requester %s, '
'but no such component registered', keycardId, requesterId)
raise errors.UnknownComponentError(requesterId)
return self.heaven.getAvatar(requesterId).expireKeycard(keycardId)
def perspective_expireKeycards(self, requesterId, keycardIds):
"""
Expire multiple keycards (and thus the requester's connections)
issued to the given requester.
This is called by the bouncer component that authenticated
the keycards.
@param requesterId: name (avatarId) of the component that originally
requested authentication for the given keycardId
@type requesterId: str
@param keycardIds: sequence of id of keycards to expire
@type keycardIds: sequence of str
"""
if not self.heaven.hasAvatar(requesterId):
self.warning(
'asked to expire %d keycards for requester %s, '
'but no such component registered', len(keycardIds),
requesterId)
raise errors.UnknownComponentError(requesterId)
return self.heaven.getAvatar(requesterId).expireKeycards(keycardIds)