def _callMethod(self, methodName, callData, args, kwargs):
if not methodName.startswith('_'):
if '.' in methodName:
first, rest = methodName.split('.', 1)
server = self._rpc_children.get(first)
if server:
return server._callMethod(rest, callData, args, kwargs)
else:
m = getattr(self, methodName, None)
if m and getattr(m, 'rpc_exposed', False):
# Collapse arguments to a tuple early to make API error
# detection easier.
filler = ArgFiller.fromFunc(m)
if m.rpc_callData:
args = (self, callData) + args
else:
args = (self,) + args
try:
args = filler.fill(args, kwargs)
except:
# Client passed wrong arguments.
rethrow(errors.APIError)
# Pull 'self' back out before invoking.
args = args[1:]
return m(*args)
raise NoSuchMethodError(methodName)
def _doRequest(self, req, forceProxy):
resetResolv = False
lastError = response = None
timer = timeutil.BackoffTimer()
totalAttempts = 0
# Make at least 'connectAttempts' connection attempts, stopping after
# both passing the connectAttempts limit *and* hitting the end of the
# iterator.
while True:
if totalAttempts >= self.connectAttempts:
break
# Reset the failed proxy list each time around so we don't end up
# blacklisting everything if a second pass succeeds.
failedProxies = set()
if forceProxy is False:
connIterator = self.proxyMap.getProxyIter(req.url,
protocolFilter=self.proxyFilter)
else:
connIterator = [forceProxy]
for proxySpec in connIterator:
totalAttempts += 1
if proxySpec == proxy_map.DirectConnection:
proxySpec = None
elif not forceProxy and self._shouldBypass(req.url, proxySpec):
proxySpec = None
if lastError:
if proxySpec == self.lastProxy:
log.debug("Failed to open URL %s; trying again: %s",
req.url, lastError.format())
else:
log.info("Failed to open URL %s; trying the next "
"proxy: %s", req.url, lastError.format())
try:
req.reset()
except:
log.exception("Failed to rewind request body file, "
"unable to retry request:")
break
# If a proxy was used, save it here
self.lastProxy = proxySpec
try:
response = self._requestOnce(req, proxySpec)
break
except http_error.RequestError, err:
# Retry if an error occurred while sending the request.
lastError = err.wrapped
err = lastError.value
if lastError.check(socket.error):
self._processSocketError(err)
lastError.replace(err)
except httplib.BadStatusLine:
# closed connection without sending a response.
lastError = util.SavedException()
except socket.error, err:
# Fatal error, but attach proxy information to it.
self._processSocketError(err)
util.rethrow(err, False)
def configLine(self, line, fileName = "override", lineno = '<No line>'):
line = line.strip()
line = line.replace('\\\\', '\0').replace('\\#', '\1')
line = line.split('#', 1)[0]
if not line:
return
line = line.replace('\0', '\\').replace('\1', '#')
parts = line.split(None, 1)
if len(parts) == 1:
key = parts[0]
val = ''
else:
(key, val) = parts
if key.lower() in self._cfg_def.directives:
funcName, args, kwargs = self._cfg_def.directives[key.lower()]
fn = getattr(self, funcName)
try:
fn(val, *args, **kwargs)
except Exception, err:
if errors.exceptionIsUncatchable(err):
raise
util.rethrow(ParseError("%s:%s: when processing %s: %s"
% (fileName, lineno, key, err)))
def configLine(self, line, fileName = "override", lineno = '<No line>'):
line = line.strip()
line = line.replace('\\\\', '\0').replace('\\#', '\1')
line = line.split('#', 1)[0]
if not line:
return
line = line.replace('\0', '\\').replace('\1', '#')
parts = line.split(None, 1)
if len(parts) == 1:
key = parts[0]
val = ''
else:
(key, val) = parts
if key.lower() in self._cfg_def.directives:
funcName, args, kwargs = self._cfg_def.directives[key.lower()]
fn = getattr(self, funcName)
try:
fn(val, *args, **kwargs)
except Exception, err:
if errors.exceptionIsUncatchable(err):
raise
util.rethrow(ParseError("%s:%s: when processing %s: %s"
% (fileName, lineno, key, err)))
def __init__(self, busClient, dispatcherId=None):
if dispatcherId is None:
try:
dispatcherId = findBusNode(busClient,
dispatcher.Dispatcher.sessionClass)
except OpenError, err:
rethrow(BuildSystemUnreachableError)
if dispatcherId is None:
raise BuildSystemUnreachableError(
"Could not contact the dispatcher")
def request(self, address, contentType, request_body, response_filter):
try:
conn = self.make_connection(address)
self.send_request(conn, address)
self.send_host(conn, address)
self.send_user_agent(conn)
self.send_authorization(conn, address)
self.send_content(conn, contentType, request_body)
except socket.error, err:
rethrow(errors.OpenError("Error contacting server at %s: %s" %
(address, err)))
def __init__(self, busClient, dispatcherId=None):
if dispatcherId is None:
try:
dispatcherId = findBusNode(busClient,
dispatcher.Dispatcher.sessionClass)
except OpenError, err:
rethrow(BuildSystemUnreachableError)
if dispatcherId is None:
raise BuildSystemUnreachableError(
"Could not contact the dispatcher")
def request(self, url, body, verbose=0):
self.verbose = verbose
req = self.opener.newRequest(url,
method='POST',
headers=self.extraHeaders)
req.setAbortCheck(self.abortCheck)
req.setData(body, compress=self.compress)
if self.entitlement:
req.headers['X-Conary-Entitlement'] = self.entitlement
if self.serverName:
req.headers['X-Conary-Servername'] = self.serverName
req.headers['User-agent'] = self.user_agent
# Make sure we capture some useful information from the
# opener, even if we failed
try:
try:
response = self.opener.open(req)
except AbortError:
raise
except http_error.ResponseError, err:
if err.errcode == 403:
raise errors.InsufficientPermission(
repoName=self.serverName, url=url)
elif err.errcode == 500:
raise errors.InternalServerError(err)
else:
# Already has adequate URL information, so just rethrow it
# without modifying the message.
util.rethrow(errors.OpenError, False)
except (socket.error, EnvironmentError, http_error.TransportError):
e_type, e_value, e_tb = sys.exc_info()
if isinstance(e_value, socket.error):
errmsg = http_error.splitSocketError(e_value)[1]
elif isinstance(e_value, EnvironmentError):
errmsg = e_value.sterror
# sometimes there is a socket error hiding inside an
# IOError!
if isinstance(errmsg, socket.error):
errmsg = http_error.splitSocketError(errmsg)[1]
else:
e_name = getattr(e_type, '__name__', 'Unknown Error')
errmsg = '%s: %s' % (e_name, e_value)
raise errors.OpenError(
"Error occurred opening repository %s: %s" %
(url, errmsg)), None, e_tb
else:
self.responseHeaders = response.headers
self.responseProtocol = response.protocolVersion
return self.parse_response(response)
def request(self, url, body, verbose=0):
self.verbose = verbose
req = self.opener.newRequest(url, method='POST',
headers=self.extraHeaders)
req.setAbortCheck(self.abortCheck)
req.setData(body, compress=self.compress)
if self.entitlement:
req.headers['X-Conary-Entitlement'] = self.entitlement
if self.serverName:
req.headers['X-Conary-Servername'] = self.serverName
req.headers['User-agent'] = self.user_agent
req.headers['Accept'] = ','.join(self.contentTypes + [self.mixedType])
# Make sure we capture some useful information from the
# opener, even if we failed
try:
try:
response = self.opener.open(req)
except AbortError:
raise
except http_error.ResponseError, err:
if err.errcode == 403:
raise errors.InsufficientPermission(
repoName=self.serverName, url=url)
elif err.errcode == 500:
raise errors.InternalServerError(err)
else:
# Already has adequate URL information, so just rethrow it
# without modifying the message.
util.rethrow(errors.OpenError, False)
except (socket.error, EnvironmentError, http_error.TransportError):
e_type, e_value, e_tb = sys.exc_info()
if isinstance(e_value, socket.error):
errmsg = http_error.splitSocketError(e_value)[1]
elif isinstance(e_value, EnvironmentError):
errmsg = e_value.strerror
# sometimes there is a socket error hiding inside an
# IOError!
if isinstance(errmsg, socket.error):
errmsg = http_error.splitSocketError(errmsg)[1]
else:
e_name = getattr(e_type, '__name__', 'Unknown Error')
errmsg = '%s: %s' % (e_name, e_value)
raise errors.OpenError(
"Error occurred opening repository %s: %s" %
(url, errmsg)), None, e_tb
else:
self.responseHeaders = response.headers
self.responseProtocol = response.protocolVersion
return self.parse_response(response)
def _openDb(self):
if not self._db:
self._db = dbstore.connect(self._cfg.dbPath, self._cfg.dbDriver)
self._autoDb = True
# check to make sure the schema version is correct
try:
schema.checkVersion(self._db)
except sqlerrors.SchemaVersionError:
rethrow(mint_error.DatabaseVersionMismatch, False)
tables = TableCache(self._db, self._cfg)
self._copyTables(tables)
if self._db.inTransaction(True):
self._db.commit()
def _doRequest(self, req, forceProxy):
resetResolv = False
lastError = response = None
timer = timeutil.BackoffTimer()
totalAttempts = 0
# Make at least 'connectAttempts' connection attempts, stopping after
# both passing the connectAttempts limit *and* hitting the end of the
# iterator.
while True:
if totalAttempts >= self.connectAttempts:
break
# Reset the failed proxy list each time around so we don't end up
# blacklisting everything if a second pass succeeds.
failedProxies = set()
if forceProxy is False:
connIterator = self.proxyMap.getProxyIter(
req.url, protocolFilter=self.proxyFilter)
else:
connIterator = [forceProxy]
for proxySpec in connIterator:
totalAttempts += 1
if proxySpec == proxy_map.DirectConnection:
proxySpec = None
elif not forceProxy and self._shouldBypass(req.url, proxySpec):
proxySpec = None
if lastError:
if proxySpec == self.lastProxy:
log.debug("Failed to open URL %s; trying again: %s",
req.url, lastError.format())
else:
log.info(
"Failed to open URL %s; trying the next "
"proxy: %s", req.url, lastError.format())
try:
req.reset()
except:
log.exception("Failed to rewind request body file, "
"unable to retry request:")
break
# If a proxy was used, save it here
self.lastProxy = proxySpec
try:
response = self._requestOnce(req, proxySpec)
break
except http_error.RequestError, err:
# Retry if an error occurred while sending the request.
lastError = err.wrapped
err = lastError.value
if lastError.check(socket.error):
self._processSocketError(err)
lastError.replace(err)
except httplib.BadStatusLine:
# closed connection without sending a response.
lastError = util.SavedException()
except socket.error, err:
# Fatal error, but attach proxy information to it.
self._processSocketError(err)
util.rethrow(err, False)