def _getHandler(self):
self.baseUrl = self.req.application_url + '/'
self.httpsUrl = self.req.application_url.replace('http://', 'https://') + '/'
self.hostName = self.req.host.rsplit(':', 1)[0]
self.SITE = self.req.host + '/'
self.siteHost = self.cfg.siteHost
self.isOwner = self.userLevel == userlevels.OWNER or self.auth.admin
# Handle messages stashed in the session
self.infoMsg = self.session.setdefault('infoMsg', '')
self.searchType = self.session.setdefault('searchType', getProjectText().title()+"s")
self.searchTerms = ''
self.errorMsgList = self._getErrors()
# a set of information to be passed into the next handler
context = {
'auth': self.auth,
'authToken': self.auth.getToken(),
'client': self.client,
'cfg': self.cfg,
'db': self.db,
'fields': self.fields,
'req': self.req,
'response': self.response,
'session': self.session,
'siteHost': self.cfg.siteHost,
'searchType': self.searchType,
'searchTerms': '',
'toUrl': self.req.url,
'baseUrl': self.baseUrl,
'basePath': self.basePath,
'httpsUrl': self.httpsUrl,
'hostName': self.hostName,
'project': None,
'SITE': self.SITE,
'userLevel': self.userLevel,
'user': self.user,
'isOwner': self.isOwner,
'infoMsg': self.infoMsg,
'errorMsgList': self.errorMsgList,
'output': self.output,
'remoteIp': self.req.client_addr,
'reposShim': self.reposShim,
}
# match the requested url to the right url handler
for match, urlHandler in [
('admin', self.adminHandler),
('administer', self.adminHandler),
('unknownError', self.errorHandler),
]:
if self.req.path_info_peek() == match:
self.req.path_info_pop()
break
else:
urlHandler = self.siteHandler
context['cmd'] = self.req.path_info
return urlHandler.handle(context)
def external(self, auth):
pText = getProjectText().title()
regColumns = ['%s Name'%pText, 'Mirrored']
regRows = []
# iterate through all projects, set up the
# regular project rows, and save the mirrored
# projects for later.
# NB: It would be great to not have to reach around the XMLRPC layer
# here, but the old way scales very poorly (>30s on rBO w/ 12000
# projects).
mirroredProjects = []
for repos in self.client.server._server.reposMgr.iterRepositories(
'external'):
project = self.client.getProject(repos.projectId)
mirrored = self.client.getInboundMirror(project.id)
if not mirrored:
data = [('editExternal?projectId=%s' % project.id, project.name),
bool(mirrored) and 'Yes' or 'No']
regRows.append({'columns': data})
else:
mirroredProjects.append((project, mirrored))
# set up the mirrored projects list
mirroredProjects.sort(key = lambda x: x[1]['mirrorOrder'])
mirrorColumns = ['Mirrored %s Name'%pText, 'Order']
mirrorRows = []
for i, (project, mirrored) in enumerate(mirroredProjects):
orderHtml = self._makeMirrorOrderingLinks("InboundMirror",
len(mirroredProjects), mirrored['mirrorOrder'], i, mirrored['inboundMirrorId'])
data = [('editExternal?projectId=%s' % project.id, project.name), orderHtml]
mirrorRows.append({'columns': data})
return self._write('admin/external',
regColumns = regColumns, regRows = regRows,
mirrorColumns = mirrorColumns, mirrorRows = mirrorRows)
def _validateExternalProject(self, name, hostname, label, url,
externalUser, externalPass,
externalEntKey,
useMirror, authType,
additionalLabelsToMirror, allLabels, backupExternal):
additionalLabels = []
extLabel = ""
pText = getProjectText().lower()
# Validate simple parameters
if not name:
self._addErrors("Missing %s title"%pText)
if not hostname:
self._addErrors("Missing %s name"%pText)
if not label:
self._addErrors("Missing %s label"%pText)
else:
try:
extLabel = versions.Label(label)
except versions.ParseError:
self._addErrors("Invalid label %s" % label)
if self._getErrors():
return None, None
# Parse and check additional labels
if useMirror == 'net' and additionalLabelsToMirror:
for l in additionalLabelsToMirror.split():
# skip a redundant label specification
if l != label:
try:
versions.Label(l)
additionalLabels.append(l)
except versions.ParseError:
self._addErrors("Invalid additional label %s" % l)
# Check authentication data
if authType != 'none':
if authType == 'userpass':
if not externalUser:
self._addErrors("Missing username for local mirror authentication")
if not externalPass:
self._addErrors("Missing password for local mirror authentication")
elif authType == 'entitlement':
if not externalEntKey:
self._addErrors('Missing entitlement key for local mirror authentication')
else:
# Test that the entitlement is valid
cfg = conarycfg.ConaryConfiguration()
if url:
cfg.configLine('repositoryMap %s %s' % (extLabel.host,
url))
cfg.entitlement.addEntitlement(extLabel.host, externalEntKey)
cfg = configureClientProxies(cfg, False, self.cfg.proxy)
nc = conaryclient.ConaryClient(cfg).getRepos()
try:
# use 2**64 to ensure we won't make the server do much
nc.getNewTroveList(extLabel.host, '4611686018427387904')
except errors.InsufficientPermission:
self._addErrors("Entitlement does not grant mirror access to external repository")
except errors.OpenError, e:
if url:
self._addErrors("Error contacting remote repository. Please ensure entitlement and repository URL are correct. (%s)" % str(e))
else:
self._addErrors("Error contacting remote repository. Please ensure entitlement is correct. (%s)" % str(e) )
def processAddExternal(self, name, hostname, label, url,
externalUser, externalPass,
externalEntKey,
useMirror, authType, additionalLabelsToMirror,
projectId, allLabels, backupExternal, backgroundMirror,
*args, **kwargs):
# strip extraneous whitespace
externalEntKey = externalEntKey.strip()
kwargs = {'name': name, 'hostname': hostname, 'label': label,
'url': url, 'authType': authType, 'externalUser': externalUser,
'externalPass': externalPass,
'externalEntKey': externalEntKey,
'useMirror': useMirror,
'additionalLabelsToMirror': additionalLabelsToMirror,
'allLabels': allLabels,
'backupExternal': backupExternal,
}
editing = (projectId != -1)
externalAuth = (authType != 'none')
additionalLabels, extLabel = self._validateExternalProject(**kwargs)
if not self._getErrors():
if not editing:
projectId = self.client.newExternalProject(name, hostname,
self.cfg.projectDomainName, label, url, useMirror == 'net')
project = self.client.getProject(projectId)
if editing:
project.editProject(project.projecturl, project.description, name)
project.setBackupExternal(backupExternal)
labelIdMap = self.client.getLabelsForProject(projectId)[0]
label, labelId = labelIdMap.items()[0]
if not url and not externalAuth:
url = "http://%s/conary/" % extLabel.getHost()
elif not url and externalAuth:
url = "https://%s/conary/" % extLabel.getHost()
if not authType in ('none', 'userpass', 'entitlement'):
raise RuntimeError, "Invalid authentication type specified"
# set up the authentication
project.editLabel(labelId, str(extLabel), url,
authType, externalUser, externalPass, externalEntKey)
inboundMirror = self.client.getInboundMirror(projectId)
# set up the mirror, if requested
if useMirror == 'net':
project.editLabel(labelId, str(extLabel),
'', 'none', '', '', '')
if inboundMirror and editing:
mirrorId = inboundMirror['inboundMirrorId']
self.client.editInboundMirror(mirrorId, [str(extLabel)] +
additionalLabels, url, authType, externalUser,
externalPass, externalEntKey, allLabels)
else:
self.client.addInboundMirror(projectId, [str(extLabel)] +
additionalLabels, url, authType, externalUser,
externalPass, externalEntKey, allLabels)
# remove mirroring if requested
elif useMirror == 'none' and inboundMirror and editing:
self.client.delInboundMirror(inboundMirror['inboundMirrorId'])
verb = editing and "Edited" or "Added"
self._setInfo("%s external %s %s" % (verb, getProjectText().lower(), name))
self._redirectHttp("admin/external")
else:
if editing:
return self.editExternal(projectId = projectId, **kwargs)
else:
return self.addExternal(**kwargs)
def projectText():
return getProjectText()
