def get_callback(response, sip_uri=sip_uri):
"""
Handle response to initial GET, only PUT new data if there
wasn't anything there.
"""
global num_responses, num_requests
print "%s Get response %s" % (sip_uri, response.code)
if response.code == 404:
print "%s needs to be repopulated" % (sip_uri, )
xdm.put_simservs(sip_uri, xml, put_callback)
else:
inc_resp_count()
def get_callback(response, sip_uri=sip_uri):
"""
Handle response to initial GET, only PUT new data if there
wasn't anything there.
"""
global num_responses, num_requests
print "%s Get response %s" % (sip_uri, response.code)
if response.code == 404:
print "%s needs to be repopulated" % (sip_uri,)
xdm.put_simservs(sip_uri, xml, put_callback)
else:
inc_resp_count()
def test_put_simservs(self, settings, AsyncHTTPClient):
settings.XDM_URL = "xdm"
client = Mock()
AsyncHTTPClient.return_value = client
callback = Mock()
xdm.put_simservs(SIP_URI, XML, callback)
client.fetch.assert_called_once_with(SIMSERVS_URL,
callback,
method="PUT",
body=XML,
headers={"X-XCAP-Asserted-Identity": SIP_URI})
def test_put_simservs(self, settings, AsyncHTTPClient):
settings.XDM_URL = "xdm"
client = Mock()
AsyncHTTPClient.return_value = client
callback = Mock()
xdm.put_simservs(SIP_URI, XML, callback)
client.fetch.assert_called_once_with(SIMSERVS_URL,
callback,
method="PUT",
body=XML,
headers={"X-XCAP-Asserted-Identity": SIP_URI},
allow_ipv6=True)
def post(self, username):
"""Allocate a phone number."""
_log.debug("Number allocation API call (PSTN = %s)", self.get_argument('pstn', 'false'))
user_id = self.get_and_check_user_id(username)
db_sess = self.db_session()
pstn = self.get_argument('pstn', 'false') == 'true'
private_id = self.get_argument('private_id', None)
try:
number_id = numbers.allocate_number(db_sess, user_id, pstn)
sip_uri = numbers.get_number(db_sess, number_id, user_id)
self.sip_uri = sip_uri
_log.debug("SIP URI %s", sip_uri)
# FIXME We shouldn't commit until we know XDM/HS have succeeded but
# if we hold the transaction open we can deadlock
# * Request 1 comes in and allocates a number, kicks off requests
# to XDM/Homestead, has transaction open, returns thread to Tornado
# * Request 2 comes in, allocates same number, can't lock it for
# update because Request 1 is holding it. Blocks.
# * Request 1 gets response but the thread is tied up
# * Request 2 SQL transaction times out.
# * Request 1 probably completes..
db_sess.commit()
except NotFound:
# FIXME email operator to tell them we're out of numbers!
_log.warning("No available numbers")
raise HTTPError(httplib.SERVICE_UNAVAILABLE,
"No available numbers")
# Work out the response we'll send if the upstream requests
# are successful.
number = utils.sip_uri_to_phone_number(sip_uri)
pretty_number = utils.format_phone_number(number)
self.__response = {"sip_uri": sip_uri,
"sip_username": number,
"number": number,
"pstn": pstn,
"formatted_number": pretty_number,
"number_id": number_id.hex}
# Generate a random password and store it in Homestead.
_log.debug("Populating other servers...")
self._request_group = HTTPCallbackGroup(self._on_post_success,
self._on_post_failure)
public_callback = self._request_group.callback()
if private_id == None:
# No private id was provided, so we need to create a new
# digest in Homestead
private_id = utils.sip_public_id_to_private(sip_uri)
sip_password = utils.generate_sip_password()
homestead.create_private_id(private_id,
sip_password,
self._request_group.callback())
self.__response["sip_password"] = sip_password
# Associate the new public identity with the private identity in Homestead
# and store the iFCs in homestead.
homestead.create_public_id(private_id,
sip_uri,
ifcs.generate_ifcs(settings.SIP_DIGEST_REALM),
public_callback)
self.__response["private_id"] = private_id
# Concurrently, store the default simservs in XDM.
with open(settings.XDM_DEFAULT_SIMSERVS_FILE) as xml_file:
default_xml = xml_file.read()
xdm.put_simservs(sip_uri, default_xml, self._request_group.callback())
def post(self, username, sip_uri):
"""Allocate a phone number."""
_log.debug("Specific number allocation API call (%s)", sip_uri)
self.is_admin_request()
user_id = self.get_and_check_user_id(username)
db_sess = self.db_session()
pstn = self.get_argument("pstn", "false").lower() == "true"
private_id = self.get_argument("private_id", None)
new_private_id = self.get_argument("new_private_id", "false").lower() == "true"
try:
number_id = uuid.UUID(numbers.get_sip_uri_number_id(db_sess, sip_uri))
except NotFound:
# This SIP URI is not currently in the pool, so add it
number_id = numbers.add_number_to_pool(db_sess, sip_uri, False, True)
numbers.allocate_specific_number(db_sess, user_id, number_id)
self.sip_uri = sip_uri
db_sess.commit()
# Work out the response we'll send if the upstream requests
# are successful.
number = utils.sip_uri_to_phone_number(sip_uri)
pretty_number = format_phone_number(number)
self.__response = {
"sip_uri": sip_uri,
"sip_username": number,
"number": number,
"pstn": pstn,
"formatted_number": pretty_number,
"number_id": number_id.hex,
}
# Generate a random password and store it in Homestead.
_log.debug("Populating other servers...")
self._request_group = HTTPCallbackGroup(self._on_post_success, self._on_post_failure)
public_callback = self._request_group.callback()
if private_id == None:
# No private id was provided, so we need to create a new
# digest in Homestead
private_id = utils.sip_public_id_to_private(sip_uri)
new_private_id = True
if new_private_id:
sip_password = utils.generate_sip_password()
_log.debug("About to create private ID at Homestead")
homestead.create_private_id(
private_id, utils.sip_uri_to_domain(sip_uri), sip_password, self._request_group.callback()
)
_log.debug("Created private ID at Homestead")
self.__response["sip_password"] = sip_password
self.__response["sip_username"] = private_id
# Associate the new public identity with the private identity in Homestead
# and store the iFCs in homestead.
homestead.create_public_id(
private_id, sip_uri, ifcs.generate_ifcs(utils.sip_uri_to_domain(sip_uri)), public_callback
)
self.__response["private_id"] = private_id
# Concurrently, store the default simservs in XDM.
with open(settings.XDM_DEFAULT_SIMSERVS_FILE) as xml_file:
default_xml = xml_file.read()
xdm.put_simservs(sip_uri, default_xml, self._request_group.callback())
def post(self, username, sip_uri): # pragma: no cover
"""Allocate a phone number."""
_log.debug("Specific number allocation API call (%s)", sip_uri)
self.is_admin_request()
user_id = self.get_and_check_user_id(username)
db_sess = self.db_session()
pstn = self.get_argument('pstn', 'false').lower() == 'true'
private_id = self.get_argument('private_id', None)
new_private_id = self.get_argument('new_private_id',
'false').lower() == 'true'
try:
number_id = uuid.UUID(
numbers.get_sip_uri_number_id(db_sess, sip_uri))
except NotFound:
# This SIP URI is not currently in the pool, so add it
number_id = numbers.add_number_to_pool(db_sess, sip_uri, False,
True)
numbers.allocate_specific_number(db_sess, user_id, number_id)
self.sip_uri = sip_uri
db_sess.commit()
# Work out the response we'll send if the upstream requests
# are successful.
number = utils.sip_uri_to_phone_number(sip_uri)
pretty_number = format_phone_number(number)
self.__response = {
"sip_uri": sip_uri,
"sip_username": number,
"number": number,
"pstn": pstn,
"formatted_number": pretty_number,
"number_id": number_id.hex
}
# Generate a random password and store it in Homestead.
_log.debug("Populating other servers...")
self._request_group = HTTPCallbackGroup(self._on_post_success,
self._on_post_failure)
public_callback = self._request_group.callback()
if private_id == None:
# No private id was provided, so we need to create a new
# digest in Homestead
private_id = utils.sip_public_id_to_private(sip_uri)
new_private_id = True
if new_private_id:
sip_password = utils.generate_sip_password()
_log.debug("About to create private ID at Homestead")
homestead.create_private_id(private_id,
utils.sip_uri_to_domain(sip_uri),
sip_password,
self._request_group.callback())
_log.debug("Created private ID at Homestead")
self.__response["sip_password"] = sip_password
self.__response["sip_username"] = private_id
# Associate the new public identity with the private identity in Homestead
# and store the iFCs in homestead.
homestead.create_public_id(
private_id, sip_uri,
ifcs.generate_ifcs(utils.sip_uri_to_domain(sip_uri)),
public_callback)
self.__response["private_id"] = private_id
# Concurrently, store the default simservs in XDM.
xdm.put_simservs(sip_uri, simservs.default_simservs(),
self._request_group.callback())
def post(self, username):
"""Allocate a phone number."""
_log.debug("Number allocation API call (PSTN = %s)",
self.get_argument('pstn', 'false'))
user_id = self.get_and_check_user_id(username)
db_sess = self.db_session()
pstn = self.get_argument('pstn', 'false').lower() == 'true'
private_id = self.get_argument('private_id', None)
try:
number_id = numbers.allocate_number(db_sess, user_id, pstn)
sip_uri = numbers.get_number(db_sess, number_id, user_id)
self.sip_uri = sip_uri
_log.debug("SIP URI %s", sip_uri)
# FIXME We shouldn't commit until we know XDM/HS have succeeded but
# if we hold the transaction open we can deadlock
# * Request 1 comes in and allocates a number, kicks off requests
# to XDM/Homestead, has transaction open, returns thread to Tornado
# * Request 2 comes in, allocates same number, can't lock it for
# update because Request 1 is holding it. Blocks.
# * Request 1 gets response but the thread is tied up
# * Request 2 SQL transaction times out.
# * Request 1 probably completes..
db_sess.commit()
except NotFound: # pragma: no cover
# FIXME email operator to tell them we're out of numbers!
db_sess.rollback()
_log.warning("No available numbers")
raise HTTPError(httplib.SERVICE_UNAVAILABLE,
"No available numbers")
# Work out the response we'll send if the upstream requests
# are successful.
number = utils.sip_uri_to_phone_number(sip_uri)
pretty_number = format_phone_number(number)
self.__response = {
"sip_uri": sip_uri,
"sip_username": number,
"number": number,
"pstn": pstn,
"formatted_number": pretty_number,
"number_id": number_id.hex
}
# Generate a random password and store it in Homestead.
_log.debug("Populating other servers...")
self._request_group = HTTPCallbackGroup(self._on_post_success,
self._on_post_failure)
public_callback = self._request_group.callback()
if private_id == None:
# No private id was provided, so we need to create a new
# digest in Homestead
private_id = utils.sip_public_id_to_private(sip_uri)
sip_password = utils.generate_sip_password()
_log.debug("About to create private ID at Homestead")
homestead.create_private_id(private_id,
utils.sip_uri_to_domain(sip_uri),
sip_password,
self._request_group.callback())
_log.debug("Created private ID at Homestead")
self.__response["sip_password"] = sip_password
# Associate the new public identity with the private identity in Homestead
# and store the iFCs in homestead.
homestead.create_public_id(
private_id, sip_uri,
ifcs.generate_ifcs(utils.sip_uri_to_domain(sip_uri)),
public_callback)
self.__response["private_id"] = private_id
# Concurrently, store the default simservs in XDM.
xdm.put_simservs(sip_uri, simservs.default_simservs(),
self._request_group.callback())