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)