def delete_cert(self, project_id, domain_name, cert_type):
"""delete_cert
Delete a certificate.
:param project_id
:param domain_name
:param cert_type
:raises ValueError
"""
args = {'domain_name': domain_name.lower()}
stmt = query.SimpleStatement(
CQL_SEARCH_CERT_BY_DOMAIN,
consistency_level=self._driver.consistency_level)
resultset = self.session.execute(stmt, args)
complete_results = list(resultset)
if complete_results:
for r in complete_results:
r_project_id = str(r.get('project_id'))
r_cert_type = str(r.get('cert_type'))
if r_project_id == str(project_id) and \
r_cert_type == str(cert_type):
args = {'domain_name': str(r.get('domain_name'))}
stmt = query.SimpleStatement(
CQL_DELETE_CERT,
consistency_level=self._driver.consistency_level)
self.session.execute(stmt, args)
stmt = query.SimpleStatement(
CQL_DELETE_CERT_STATUS,
consistency_level=self._driver.consistency_level)
self.session.execute(stmt, args)
else:
raise ValueError("No certificate found for: {0},"
"type: {1}".format(domain_name, cert_type))
def delete_services_by_status(self, project_id, service_id, status):
LOG.info("Deleting service_id: {0} "
"with project_id: {1} with status: {2} from service_status "
"column family".format(service_id, project_id, status))
args = {
'service_id': uuid.UUID(str(service_id))
}
stmt = query.SimpleStatement(
CQL_DELETE_SERVICE_STATUS,
consistency_level=self._driver.consistency_level)
self.session.execute(stmt, args)
def get_domains_by_provider_url(self, provider_url):
LOG.info("Getting domains by provider_url: {0}".format(provider_url))
get_domain_provider_url_args = {
'provider_url': provider_url,
}
stmt = query.SimpleStatement(
CQL_GET_BY_PROVIDER_URL,
consistency_level=self._driver.consistency_level)
resultset = self.session.execute(stmt, get_domain_provider_url_args)
return list(resultset)
def _get_akamai_provider_info(self):
args = {
"provider_name": 'akamai'
}
stmt = query.SimpleStatement(
GET_PROVIDER_INFO,
consistency_level=self.consistency_level)
results = self.session.execute(stmt, args)
complete_results = list(results)
if len(complete_results) != 1:
raise ValueError('No akamai providers info found.')
result = complete_results[0]
return result
def delete_provider_url(self, provider_url, domain_name):
LOG.info("Deleting provider_url: {0} and "
"domain_name: {1} from provider_url_domain "
"column family".format(provider_url, domain_name))
del_provider_url_args = {
'provider_url': provider_url,
'domain_name': domain_name
}
stmt = query.SimpleStatement(
CQL_DELETE_PROVIDER_URL,
consistency_level=self._driver.consistency_level)
self.session.execute(stmt, del_provider_url_args)
def get_provider_details(self, project_id, service_id):
"""get_provider_details.
:param project_id
:param service_id
:returns results Provider details
"""
args = {
'project_id': project_id,
'service_id': uuid.UUID(str(service_id))
}
# TODO(tonytan4ever): Not sure this returns a list or a single
# dictionary.
# Needs to verify after cassandra unittest framework has been added in
# if a list, the return the first item of a list. if it is a dictionary
# returns the dictionary
stmt = query.SimpleStatement(
CQL_GET_PROVIDER_DETAILS,
consistency_level=self._driver.consistency_level)
exec_results_set = self.session.execute(stmt, args)
complete_results = list(exec_results_set)
if len(complete_results) != 1:
raise ValueError('No service found: %s'
% service_id)
provider_details_result = complete_results[0]['provider_details'] or {}
results = {}
for provider_name in provider_details_result:
provider_detail_dict = json.loads(
provider_details_result[provider_name])
provider_service_id = provider_detail_dict.get('id', None)
access_urls = provider_detail_dict.get("access_urls", [])
status = provider_detail_dict.get("status", u'creating')
domains_certificate_status = (
provider_detail_dict.get('domains_certificate_status', {}))
error_info = provider_detail_dict.get("error_info", None)
error_message = provider_detail_dict.get("error_message", None)
provider_detail_obj = provider_details.ProviderDetail(
provider_service_id=provider_service_id,
access_urls=access_urls,
status=status,
domains_certificate_status=domains_certificate_status,
error_info=error_info,
error_message=error_message)
results[provider_name] = provider_detail_obj
return results
def get_services_by_status(self, status):
LOG.info("Fetching service_ids and "
"project_ids with status: {0}".format(status))
args = {'status': status}
stmt = query.SimpleStatement(
CQL_GET_SERVICE_STATUS,
consistency_level=self._driver.consistency_level)
resultset = self.session.execute(stmt, args)
complete_results = list(resultset)
for result in complete_results:
result['service_id'] = str(result['service_id'])
return complete_results
def cert_already_exist(self, domain_name, comparing_cert_type,
comparing_flavor_id,
comparing_project_id):
"""cert_already_exist
Check if a cert with this domain name and type has already been
created, or if the domain has been taken by other customers
:param domain_name
:param cert_type
:param comparing_project_id
:raises ValueError
:returns Boolean if the cert with same type exists with another user.
"""
LOG.info("Check if cert on '{0}' exists".format(domain_name))
args = {
'domain_name': domain_name.lower()
}
stmt = query.SimpleStatement(
CQL_VERIFY_CERT,
consistency_level=self._driver.consistency_level)
results = self.session.execute(stmt, args)
if results:
msg = None
for r in results:
if str(r.get('project_id')) != str(comparing_project_id):
msg = "Domain '{0}' has already been created cert by {1}"\
.format(domain_name, r.get('project_id'))
LOG.warn(msg)
raise ValueError(msg)
elif (str(r.get('flavor_id')) == str(comparing_flavor_id)
and
str(r.get('cert_type')) == str(comparing_cert_type)):
msg = "{0} have already created cert of type {1} on {2}"\
.format(str(comparing_project_id),
comparing_cert_type,
domain_name)
LOG.warn(msg)
raise ValueError(msg)
return False
else:
return False
def set_san_cert_hostname_limit(self, new_hostname_limit):
settings = self._get_akamai_san_certs_settings()
if settings is None:
raise ValueError('No san cert settings found.')
settings['san_cert_hostname_limit'] = new_hostname_limit
# Change the previous san info in the overall provider_info dictionary
provider_info = dict(self._get_akamai_provider_info()['info'])
provider_info['settings'] = json.dumps(settings)
stmt = query.SimpleStatement(UPDATE_PROVIDER_INFO,
consistency_level=self.consistency_level)
args = {'provider_name': 'akamai', 'info': provider_info}
self.session.execute(stmt, args)
return self.get_san_cert_hostname_limit()
def update_provider_details(self, project_id, service_id,
provider_details):
"""update_provider_details.
:param project_id
:param service_id
:param provider_details
"""
provider_detail_dict = {}
for provider_name in sorted(provider_details.keys()):
the_provider_detail_dict = collections.OrderedDict()
the_provider_detail_dict["id"] = (
provider_details[provider_name].provider_service_id)
the_provider_detail_dict["access_urls"] = (
provider_details[provider_name].access_urls)
the_provider_detail_dict["status"] = (
provider_details[provider_name].status)
the_provider_detail_dict["name"] = (
provider_details[provider_name].name)
the_provider_detail_dict["domains_certificate_status"] = (
provider_details[provider_name].domains_certificate_status.
to_dict())
the_provider_detail_dict["error_info"] = (
provider_details[provider_name].error_info)
the_provider_detail_dict["error_message"] = (
provider_details[provider_name].error_message)
provider_detail_dict[provider_name] = json.dumps(
the_provider_detail_dict)
args = {
'project_id': project_id,
'service_id': uuid.UUID(str(service_id)),
'provider_details': provider_detail_dict
}
# TODO(tonytan4ever): Not sure this returns a list or a single
# dictionary.
# Needs to verify after cassandra unittest framework has been added in
# if a list, the return the first item of a list. if it is a dictionary
# returns the dictionary
stmt = query.SimpleStatement(
CQL_UPDATE_PROVIDER_DETAILS,
consistency_level=self._driver.consistency_level)
self.session.execute(stmt, args)
def save_cert_config(self, san_cert_name, new_cert_config):
san_info = self._get_akamai_san_certs_info()
the_san_cert_info = san_info.get(san_cert_name)
if the_san_cert_info is None:
raise ValueError('No san cert info found for %s.' % san_cert_name)
the_san_cert_info.update(new_cert_config)
san_info[san_cert_name] = the_san_cert_info
# Change the previous san info in the overall provider_info dictionary
provider_info = dict(self._get_akamai_provider_info()['info'])
provider_info['san_info'] = json.dumps(san_info)
stmt = query.SimpleStatement(UPDATE_PROVIDER_INFO,
consistency_level=self.consistency_level)
args = {'provider_name': 'akamai', 'info': provider_info}
self.session.execute(stmt, args)
def update_cert_info(self, domain_name, cert_type, flavor_id,
cert_details):
"""update_cert_info.
:param domain_name
:param cert_type
:param flavor_id
:param cert_info
"""
args = {
'domain_name': domain_name,
'cert_type': cert_type,
'flavor_id': flavor_id,
'cert_details': cert_details
}
stmt = query.SimpleStatement(
CQL_UPDATE_CERT_DETAILS,
consistency_level=self._driver.consistency_level)
self.session.execute(stmt, args)
def domain_exists_elsewhere(self, domain_name, service_id):
"""domain_exists_elsewhere
Check if a service with this domain name has already been created.
:param domain_name
:param service_id
:raises ValueError
:returns Boolean if the service exists with another user.
"""
try:
LOG.info("Check if domain '{0}' exists".format(domain_name))
args = {
'domain_name': domain_name.lower()
}
stmt = query.SimpleStatement(
CQL_VERIFY_DOMAIN,
consistency_level=self._driver.consistency_level)
results = self.session.execute(stmt, args)
if results:
LOG.info("Checking for domain '{0}'"
"existence yielded {1}".format(domain_name,
str(results)))
for r in results:
if str(r.get('service_id')) != str(service_id):
LOG.info(
"Domain '{0}' has already been taken."
.format(domain_name))
return True
return False
else:
LOG.info("Checking if domain '{0}' exists, "
"yielded no results".format(domain_name))
return False
except ValueError as ex:
LOG.warning("Checking for domain '{0}'"
"failed!".format(domain_name))
LOG.exception(ex)
return False
def create_cert(self, project_id, cert_obj):
if self.cert_already_exist(domain_name=cert_obj.domain_name,
comparing_cert_type=cert_obj.cert_type,
comparing_flavor_id=cert_obj.flavor_id,
comparing_project_id=project_id):
raise ValueError('Certificate already exists '
'for {0} '.format(cert_obj.domain_name))
args = {
'project_id': project_id,
'flavor_id': cert_obj.flavor_id,
'cert_type': cert_obj.cert_type,
'domain_name': cert_obj.domain_name,
# when create the cert, cert domain has not been assigned yet
# In future we can tweak the logic to assign cert_domain
# 'cert_domain': '',
'cert_details': cert_obj.cert_details
}
stmt = query.SimpleStatement(
CQL_CREATE_CERT, consistency_level=self._driver.consistency_level)
self.session.execute(stmt, args)
def get_service_details_by_domain_name(self, domain_name):
"""get_provider_details_by_domain_name.
:param domain_name
:returns Provider details
"""
LOG.info("Getting details of service having domain: '{0}'".format(
domain_name))
args = {
'domain_name': domain_name.lower()
}
stmt = query.SimpleStatement(
CQL_SEARCH_BY_DOMAIN,
consistency_level=self._driver.consistency_level)
results = self.session.execute(stmt, args)
for r in results:
proj_id = r.get('project_id')
service = r.get('service_id')
details = self.get(proj_id, service)
return details
def create_cert(self, project_id, cert_obj):
if not self.cert_already_exist(cert_obj.domain_name,
cert_obj.cert_type,
cert_obj.flavor_id,
project_id):
pass
args = {
'project_id': project_id,
'flavor_id': cert_obj.flavor_id,
'cert_type': cert_obj.cert_type,
'domain_name': cert_obj.domain_name,
# when create the cert, cert domain has not been assigned yet
# In future we can tweak the logic to assign cert_domain
# 'cert_domain': '',
'cert_details': cert_obj.cert_details
}
stmt = query.SimpleStatement(
CQL_CREATE_CERT,
consistency_level=self._driver.consistency_level)
self.session.execute(stmt, args)
def set_service_provider_details(self, project_id, service_id, status):
"""set_service_provider_details
Set current status on service_id under project_id.
:param project_id
:param service_id
:param status
"""
LOG.info("Setting service "
"status for "
"service_id : {0}, "
"project_id: {1} to be {2}".format(service_id,
project_id,
status))
status_args = {
'service_id': uuid.UUID(str(service_id)),
'project_id': project_id,
'status': status
}
stmt = query.SimpleStatement(
CQL_SET_SERVICE_STATUS,
consistency_level=self._driver.consistency_level)
self.session.execute(stmt, status_args)
provider_details_dict = self.get_provider_details(
project_id=project_id,
service_id=service_id)
for provider_name in sorted(provider_details_dict.keys()):
provider_details_dict[provider_name].status = status
self.update_provider_details(
project_id=project_id,
service_id=service_id,
new_provider_details=provider_details_dict
)
def get_cert_by_domain(self, domain_name, cert_type,
flavor_id,
project_id):
LOG.info(("Search for cert on '{0}', type: {1}, flavor_id: {2}, "
"project_id: {3}").format(domain_name, cert_type, flavor_id,
project_id))
args = {
'domain_name': domain_name.lower()
}
stmt = query.SimpleStatement(
CQL_SEARCH_CERT_BY_DOMAIN,
consistency_level=self._driver.consistency_level)
results = self.session.execute(stmt, args)
if results:
for r in results:
r_project_id = str(r.get('project_id'))
r_flavor_id = str(r.get('flavor_id'))
r_cert_type = str(r.get('cert_type'))
r_cert_details = {}
cert_details = r.get('cert_details', {})
# Need to convert cassandra dict into real dict
# And the value of cert_details is a string dict
for key in cert_details:
r_cert_details[key] = json.loads(cert_details[key])
if r_project_id == str(project_id) and \
r_flavor_id == str(flavor_id) and \
r_cert_type == str(cert_type):
res = ssl_certificate.SSLCertificate(r_flavor_id,
domain_name,
r_cert_type,
r_cert_details)
return res
else:
return None
else:
return None
def main(input_dir, keyspace, table):
for f in os.listdir(input_dir):
with gzip.open(os.path.join(input_dir, f), 'rt',
encoding='utf-8') as logfile:
batch = cq.BatchStatement()
for line in logfile:
line_re = re.compile(
r'^(\S+) - - \[(\S+) [+-]\d+\] \"[A-Z]+ (\S+) HTTP/\d\.\d\" \d+ (\d+)$'
)
w = re.split(line_re, line)
if len(w) == 6:
batch.add(
cq.SimpleStatement(
"INSERT INTO nasalogs (id,host,bytes,datetime,path) VALUES (%s, %s,%s, %s, %s)"
), (UUID(int=uuid4().int), w[1], int(
w[4]), convert(w[2]), w[3]))
if len(batch) % 350 == 0:
addrows = session.execute(batch)
batch.clear()
addrows = session.execute(batch)
rows = session.execute(
'SELECT path, bytes FROM nasalogs WHERE host=%s',
['in24.inetnebr.com'])
def create_certificate(self, project_id, cert_obj):
if self.cert_already_exist(domain_name=cert_obj.domain_name,
comparing_cert_type=cert_obj.cert_type,
comparing_flavor_id=cert_obj.flavor_id,
comparing_project_id=project_id):
raise ValueError('Certificate already exists '
'for {0} '.format(cert_obj.domain_name))
args = {
'project_id': project_id,
'flavor_id': cert_obj.flavor_id,
'cert_type': cert_obj.cert_type,
'domain_name': cert_obj.domain_name,
# when create the cert, cert domain has not been assigned yet
# In future we can tweak the logic to assign cert_domain
# 'cert_domain': '',
'cert_details': cert_obj.cert_details
}
stmt = query.SimpleStatement(
CQL_CREATE_CERT, consistency_level=self._driver.consistency_level)
self.session.execute(stmt, args)
cert_status = None
try:
provider_status = json.loads(
list(cert_obj.cert_details.values())[0])
cert_status = provider_status['extra_info']['status']
except (IndexError, KeyError, ValueError) as e:
LOG.warning("Create certificate missing extra info "
"status {0}: Error {1}. "
"Using 'create_in_progress' instead. ".format(
cert_obj.cert_details, e))
cert_status = 'create_in_progress'
finally:
# insert/update for cassandra
self.insert_cert_status(cert_obj.domain_name, cert_status)
def update_certificate(self, domain_name, cert_type, flavor_id,
cert_details):
args = {
'domain_name': domain_name,
'cert_type': cert_type,
'flavor_id': flavor_id,
'cert_details': cert_details
}
stmt = query.SimpleStatement(
CQL_UPDATE_CERT_DETAILS,
consistency_level=self._driver.consistency_level)
self.session.execute(stmt, args)
try:
provider_status = json.loads(list(cert_details.values())[0])
cert_status = provider_status['extra_info']['status']
self.insert_cert_status(domain_name, cert_status)
except (IndexError, KeyError, ValueError) as e:
# certs already existing in DB should have all
# the necessary fields
LOG.error("Unable to update cert_status because certificate "
"details are in an inconsistent "
"state: {0}: {1}".format(cert_details, e))
def get_certs_by_domain(self, domain_name, project_id=None,
flavor_id=None,
cert_type=None):
LOG.info("Check if cert on '{0}' exists".format(domain_name))
args = {
'domain_name': domain_name.lower()
}
stmt = query.SimpleStatement(
CQL_SEARCH_CERT_BY_DOMAIN,
consistency_level=self._driver.consistency_level)
resultset = self.session.execute(stmt, args)
complete_results = list(resultset)
certs = []
if complete_results:
for r in complete_results:
r_project_id = str(r.get('project_id'))
r_flavor_id = str(r.get('flavor_id'))
r_cert_type = str(r.get('cert_type'))
r_cert_details = {}
# in case cert_details is None
cert_details = r.get('cert_details', {}) or {}
# Need to convert cassandra dict into real dict
# And the value of cert_details is a string dict
for key in cert_details:
r_cert_details[key] = json.loads(cert_details[key])
LOG.info(
"Certificate for domain: {0} with flavor_id: {1}, "
"cert_details : {2} and cert_type: {3} present "
"on project_id: {4}".format(
domain_name,
r_flavor_id,
r_cert_details,
r_cert_type,
r_project_id
)
)
ssl_cert = ssl_certificate.SSLCertificate(
domain_name=domain_name,
flavor_id=r_flavor_id,
cert_details=r_cert_details,
cert_type=r_cert_type,
project_id=r_project_id
)
certs.append(ssl_cert)
non_none_attrs_gen = filterfalse(
lambda x: list(x.values())[0] is None, [{'project_id': project_id},
{'flavor_id': flavor_id},
{'cert_type': cert_type}])
non_none_attrs_list = list(non_none_attrs_gen)
non_none_attrs_dict = {}
if non_none_attrs_list:
for attr in non_none_attrs_list:
non_none_attrs_dict.update(attr)
def argfilter(certificate):
all_conditions = True
if non_none_attrs_dict:
for k, v in non_none_attrs_dict.items():
if getattr(certificate, k) != v:
all_conditions = False
return all_conditions
total_certs = [cert for cert in certs if argfilter(cert)]
if len(total_certs) == 1:
return total_certs[0]
else:
return total_certs
def update_provider_details(self, project_id, service_id,
new_provider_details):
"""update_provider_details.
:param project_id
:param service_id
:param new_provider_details
"""
old_domain_names_provider_urls = []
old_provider_details = self.get_provider_details(
project_id,
service_id
)
for provider_name in sorted(old_provider_details.keys()):
the_provider_detail_dict = collections.OrderedDict()
the_provider_detail_dict["id"] = (
old_provider_details[provider_name].provider_service_id)
the_provider_detail_dict["access_urls"] = (
old_provider_details[provider_name].access_urls)
for access_url in the_provider_detail_dict["access_urls"]:
domain_name = access_url.get("domain", None)
provider_url = access_url.get("provider_url", None)
if domain_name and provider_url:
old_domain_names_provider_urls.append(
(domain_name, provider_url)
)
provider_detail_dict = {}
status = None
new_domain_names_provider_urls = []
for provider_name in sorted(new_provider_details.keys()):
the_provider_detail_dict = collections.OrderedDict()
the_provider_detail_dict["id"] = (
new_provider_details[provider_name].provider_service_id)
the_provider_detail_dict["access_urls"] = (
new_provider_details[provider_name].access_urls)
for access_url in the_provider_detail_dict["access_urls"]:
domain_name = access_url.get("domain", None)
provider_url = access_url.get("provider_url", None)
if domain_name and provider_url:
new_domain_names_provider_urls.append(
(domain_name, provider_url)
)
the_provider_detail_dict["status"] = (
new_provider_details[provider_name].status)
status = the_provider_detail_dict["status"]
the_provider_detail_dict["name"] = (
new_provider_details[provider_name].name)
the_provider_detail_dict["domains_certificate_status"] = (
new_provider_details[provider_name].domains_certificate_status.
to_dict())
the_provider_detail_dict["error_info"] = (
new_provider_details[provider_name].error_info)
the_provider_detail_dict["error_message"] = (
new_provider_details[provider_name].error_message)
provider_detail_dict[provider_name] = json.dumps(
the_provider_detail_dict)
args = {
'project_id': project_id,
'service_id': uuid.UUID(str(service_id)),
'provider_details': provider_detail_dict
}
# TODO(tonytan4ever): Not sure this returns a list or a single
# dictionary.
# Needs to verify after cassandra unittest framework has been added in
# if a list, the return the first item of a list. if it is a dictionary
# returns the dictionary
stmt = query.SimpleStatement(
CQL_UPDATE_PROVIDER_DETAILS,
consistency_level=self._driver.consistency_level)
self.session.execute(stmt, args)
service_args = {
'project_id': project_id,
'service_id': uuid.UUID(str(service_id)),
'status': status
}
stmt = query.SimpleStatement(
CQL_SET_SERVICE_STATUS,
consistency_level=self._driver.consistency_level)
self.session.execute(stmt, service_args)
if new_domain_names_provider_urls:
for domain_name, provider_url in new_domain_names_provider_urls:
provider_url_args = {
'domain_name': domain_name,
'provider_url': provider_url
}
stmt = query.SimpleStatement(
CQL_SET_PROVIDER_URL,
consistency_level=self._driver.consistency_level)
self.session.execute(stmt, provider_url_args)
# remove mapping for domains that were deleted during the update
deleted_domains = (
set(old_domain_names_provider_urls) -
set(new_domain_names_provider_urls)
)
for domain_name, provider_url in deleted_domains:
provider_url_args = {
'domain_name': domain_name,
'provider_url': provider_url
}
stmt = query.SimpleStatement(
CQL_DELETE_PROVIDER_URL,
consistency_level=self._driver.consistency_level)
self.session.execute(stmt, provider_url_args)
def get_certs_by_domain(self,
domain_name,
project_id=None,
flavor_id=None,
cert_type=None):
"""Get certificate details associated with the given domain name.
The cassandra table ``certificate_info`` stores the certificates
details for domain names. The field ``domain_name`` is a unique
key in that table hence it is always guaranteed that for any
given domain name there is one and only one matching certificate.
List of valid ``cert_type``:
- san
- sni
- custom
- dedicated
:param unicode domain_name: The name of the domain
:param unicode project_id: The project id
:param unicode flavor_id: The flavor id
:param unicode cert_type: Type of the certificate
:return: Matching SSLCertificate object for the domain
:rtype: poppy.model.ssl_certificate.SSLCertificate
:raises ValueError: If no matching certificate found
"""
LOG.info("Check if cert on '{0}' exists".format(domain_name))
args = {
'domain_name': domain_name.lower(),
}
stmt = query.SimpleStatement(
CQL_SEARCH_CERT_BY_DOMAIN,
consistency_level=self._driver.consistency_level)
self.session.row_factory = dict_factory
result = self.session.execute(stmt, args)
try:
cert_obj = result[0]
for k, v in cert_obj.items():
if k == "cert_details":
# Cassandra returns OrderedMapSerializedKey for
# cert_details. Converting it to python dict.
cert_details = {}
for x, y in cert_obj[k].items():
cert_details[x] = json.loads(y)
cert_obj[k] = cert_details
else:
cert_obj[k] = str(v)
ssl_cert = ssl_certificate.SSLCertificate.init_from_dict(cert_obj)
# Check that all supplied optional parameters
# (project_id, flavor_id and cert_type ) with non-none values
# are matching with the values returned from database.
params = {
'project_id': project_id,
'flavor_id': flavor_id,
'cert_type': cert_type
}
non_none_args = \
[(k, v) for k, v in params.items() if v is not None]
for name, value in non_none_args:
if getattr(ssl_cert, name) != value:
raise ValueError("No matching certificates found for "
"the domain {}".format(domain_name))
return ssl_cert
except:
raise ValueError("No matching certificates found for "
"the domain {}".format(domain_name))
def update(self, project_id, service_id, service_obj):
"""update.
:param project_id
:param service_id
:param service_obj
"""
service_name = service_obj.name
domains = [json.dumps(d.to_dict())
for d in service_obj.domains]
origins = [json.dumps(o.to_dict())
for o in service_obj.origins]
caching_rules = [json.dumps(caching_rule.to_dict())
for caching_rule in service_obj.caching]
restrictions = [json.dumps(r.to_dict())
for r in service_obj.restrictions]
pds = {provider:
json.dumps(service_obj.provider_details[provider].to_dict())
for provider in service_obj.provider_details}
log_delivery = json.dumps(service_obj.log_delivery.to_dict())
# fetch current domains
args = {
'project_id': project_id,
'service_id': uuid.UUID(str(service_id)),
}
stmt = query.SimpleStatement(
CQL_GET_SERVICE,
consistency_level=self._driver.consistency_level)
results = self.session.execute(stmt, args)
result = results[0]
# updates an existing service
args = {
'project_id': project_id,
'service_id': uuid.UUID(str(service_id)),
'service_name': service_name,
'flavor_id': service_obj.flavor_id,
'domains': domains,
'origins': origins,
'caching_rules': caching_rules,
'restrictions': restrictions,
'provider_details': pds,
'log_delivery': log_delivery,
'operator_status': service_obj.operator_status
}
stmt = query.SimpleStatement(
CQL_UPDATE_SERVICE,
consistency_level=self._driver.consistency_level)
self.session.execute(stmt, args)
# relinquish old domains
stmt = query.SimpleStatement(
CQL_RELINQUISH_DOMAINS,
consistency_level=self._driver.consistency_level)
domain_list = [json.loads(d).get('domain')
for d in result.get('domains', []) or []]
args = {
'domain_list': query.ValueSequence(domain_list)
}
self.session.execute(stmt, args)
# claim new domains
batch_claim = query.BatchStatement(
consistency_level=self._driver.consistency_level)
for d in service_obj.domains:
domain_args = {
'domain_name': d.domain,
'project_id': project_id,
'service_id': uuid.UUID(str(service_id))
}
batch_claim.add(query.SimpleStatement(CQL_CLAIM_DOMAIN),
domain_args)
self.session.execute(batch_claim)
def update(self, project_id, service_id, service_obj):
"""update.
:param project_id
:param service_id
:param service_obj
"""
service_name = service_obj.name
domains = [json.dumps(d.to_dict()) for d in service_obj.domains]
origins = [json.dumps(o.to_dict()) for o in service_obj.origins]
caching_rules = [
json.dumps(caching_rule.to_dict())
for caching_rule in service_obj.caching
]
restrictions = [
json.dumps(r.to_dict()) for r in service_obj.restrictions
]
pds = {
provider:
json.dumps(service_obj.provider_details[provider].to_dict())
for provider in service_obj.provider_details
}
log_delivery = json.dumps(service_obj.log_delivery.to_dict())
# fetch current domains
args = {
'project_id': project_id,
'service_id': uuid.UUID(str(service_id)),
}
stmt = query.SimpleStatement(
CQL_GET_SERVICE, consistency_level=self._driver.consistency_level)
resultset = self.session.execute(stmt, args)
complete_results = list(resultset)
result = complete_results[0]
# updates an existing service
args = {
'project_id': project_id,
'service_id': uuid.UUID(str(service_id)),
'service_name': service_name,
'flavor_id': service_obj.flavor_id,
'domains': domains,
'origins': origins,
'caching_rules': caching_rules,
'restrictions': restrictions,
'provider_details': pds,
'log_delivery': log_delivery,
'operator_status': service_obj.operator_status
}
stmt = query.SimpleStatement(
CQL_UPDATE_SERVICE,
consistency_level=self._driver.consistency_level)
self.session.execute(stmt, args)
# claim new domains
batch_claim = query.BatchStatement(
consistency_level=self._driver.consistency_level)
for d in service_obj.domains:
domain_args = {
'domain_name': d.domain,
'project_id': project_id,
'service_id': uuid.UUID(str(service_id))
}
batch_claim.add(query.SimpleStatement(CQL_CLAIM_DOMAIN),
domain_args)
self.session.execute(batch_claim)
# NOTE(TheSriram): We claim (CQL_CLAIM_DOMAIN) all the domains,
# that got passed in. Now we create a set out of domains_new
# (current domains present) and domains_old (domains present before
# we made the current call). The set difference between old and new,
# are the domains we need to delete (CQL_RELINQUISH_DOMAINS).
domains_old = set([
json.loads(d).get('domain')
for d in result.get('domains', []) or []
])
domains_new = set([json.loads(d).get('domain') for d in domains or []])
# delete domains that no longer exist
# relinquish old domains
domains_delete = domains_old.difference(domains_new)
if domains_delete:
args = {'domain_list': query.ValueSequence(domains_delete)}
stmt = query.SimpleStatement(
CQL_RELINQUISH_DOMAINS,
consistency_level=self._driver.consistency_level)
self.session.execute(stmt, args)
def delete(self, project_id, service_id):
"""delete.
Archive local configuration storage
"""
# delete local configuration from storage
args = {
'project_id': project_id,
'service_id': uuid.UUID(str(service_id)),
}
# get the existing service
stmt = query.SimpleStatement(
CQL_GET_SERVICE, consistency_level=self._driver.consistency_level)
resultset = self.session.execute(stmt, args)
complete_result = list(resultset)
result = complete_result[0]
if result:
domains_list = [
json.loads(d).get('domain')
for d in result.get('domains', []) or []
]
# NOTE(obulpathi): Convert a OrderedMapSerializedKey to a Dict
pds = result.get('provider_details', {}) or {}
pds = {key: value for key, value in pds.items()}
status = None
provider_urls_domain = []
for provider in pds:
pds_provider_dict = json.loads(pds.get(provider, {}))
status = pds_provider_dict.get('status', '')
access_urls = pds_provider_dict.get('access_urls', [])
for access_url in access_urls:
provider_url = access_url.get('provider_url', None)
domain = access_url.get('domain', None)
if provider_url and domain:
provider_urls_domain.append((provider_url, domain))
self.delete_services_by_status(project_id, service_id, status)
for provider_url_domain in provider_urls_domain:
provider_url, domain = provider_url_domain
self.delete_provider_url(provider_url, domain)
if self._driver.archive_on_delete:
archive_args = {
'project_id': result.get('project_id'),
'service_id': result.get('service_id'),
'service_name': result.get('service_name'),
'flavor_id': result.get('flavor_id'),
'domains': result.get('domains', []),
'origins': result.get('origins', []),
'caching_rules': result.get('caching_rules', []),
'restrictions': result.get('restrictions', []),
'provider_details': pds,
'operator_status': result.get('operator_status',
'enabled'),
'archived_time': datetime.datetime.utcnow(),
'domains_list': query.ValueSequence(domains_list)
}
# archive and delete the service
stmt = query.SimpleStatement(
CQL_ARCHIVE_SERVICE,
consistency_level=self._driver.consistency_level)
self.session.execute(stmt, archive_args)
else:
delete_args = {
'project_id': result.get('project_id'),
'service_id': result.get('service_id'),
'domains_list': query.ValueSequence(domains_list)
}
stmt = query.SimpleStatement(
CQL_DELETE_SERVICE,
consistency_level=self._driver.consistency_level)
self.session.execute(stmt, delete_args)
def insert_cert_status(self, domain_name, cert_status):
cert_args = {'domain_name': domain_name, 'status': cert_status}
stmt = query.SimpleStatement(
CQL_INSERT_CERT_STATUS,
consistency_level=self._driver.consistency_level)
self.session.execute(stmt, cert_args)
