Python DatabaseManager.DatabaseManager类代码示例

def checkTopolgoyUniqueness(topology):
    db = DatabaseManager()
    # check names
    logger.debug("Check uniqueness of name of the toplogy \"%s\"." % topology.name)
    for top in db.get_all(Topology):
        if topology.ext_name == top.ext_name and topology.id != top.id:
            raise NotUniqueException("Topology name \"%s\" is already used." % topology.name)

 def get(cls, id):
     db = DatabaseManager()
     try:
         service = db.get_by_id(Service, id)
     except NotFoundException as e:
         raise e
     return service

 def get(cls, id):
     db = DatabaseManager()
     try:
         security_group = db.get_by_id(SecurityGroup, id)
     except NotFoundException as e:
         raise e
     return security_group

def checkSecurityGroupUniqueness(security_group):
    db = DatabaseManager()
    existing_security_groups = db.get_all(SecurityGroup)
    logger.debug("Check uniqueness of name of the security group \"%s\"." % security_group.name)
    for existing_security_group in existing_security_groups:
        if security_group.name == existing_security_group.name and security_group != existing_security_group:
            raise NotUniqueException("SecurityGroup:\"%s\" is already existing." % security_group.name)
    logger.debug("Check rules of security group \"%s\"." % security_group.name)

 def delete(cls, id):
     db = DatabaseManager()
     try:
         service_to_remove = db.get_by_id(Service, id)
     except NotFoundException as e:
         raise e
     db.remove(service_to_remove)
     return service_to_remove

 def delete(cls, id):
     db = DatabaseManager()
     try:
         security_group_to_remove = db.get_by_id(SecurityGroup, id)
     except NotFoundException as e:
         raise e
     db.remove(security_group_to_remove)
     return security_group_to_remove

class Register:

    def __init__(self):
        self.db = DatabaseManager()

    def register_unit(self, unit, ws):
        unit.ws = ws
        unit.state = 'STARTED'
        self.db.update(unit)

def checkKey(key):
    db = DatabaseManager()
    existing_keys = db.get_all(Key)
    if key.name in [existing_key.name for existing_key in existing_keys]:
        logger.debug("key \"%s\" is available." % key)
    else:
        raise NotFoundException(
            "key:\"%s\" is not available. Available keys: %s" % (
                key, [existing_key.name for existing_key in existing_keys]))

def checkFlavor(flavor):
    db = DatabaseManager()
    existing_flavors = db.get_all(Flavor)
    if flavor.name in [existing_flavor.name for existing_flavor in existing_flavors]:
        logger.debug("flavor \"%s\" is available." % flavor)
    else:
        raise NotFoundException(
            "flavor:\"%s\" is not available. Available flavors: %s" % (
                flavor, [existing_flavor.name for existing_flavor in existing_flavors]))

def checkImage(image):
    db = DatabaseManager()
    existing_images = db.get_all(Image)
    if image.name in [existing_image.name for existing_image in existing_images]:
        logger.debug("image \"%s\" is available." % image)
    else:
        raise NotFoundException(
            "image:\"%s\" is not available. Available images: %s" % (
                image, [existing_image.name for existing_image in existing_images]))

def checkNetwork(network):
    try:
        db = DatabaseManager()
        existing_networks = db.get_all(Network)
        found_private_net = False
        found_subnet = False
        found_public_net = False
        for existing_network in existing_networks:
            if network.private_net == existing_network.ext_id and not found_private_net:
                if existing_network.public == False:
                    logger.debug("private_network \"%s\" is available." % network.private_net)
                    found_private_net = True
                else:
                    raise InvalidInputException(
                        "private_network:\"%s\" is available but it is marked as public and not as private as defined." % network.private_net)
                for subnet in existing_network.subnets:
                    if network.private_subnet == subnet.ext_id and not found_subnet:
                        found_subnet = True
                if found_subnet:
                    logger.debug("private_subnet \"%s\" is available." % network.private_subnet)
                else:
                    raise InvalidInputException("private_subnet:\"%s\" is not available." % network.private_subnet)
            if network.public_net == existing_network.ext_id and not found_public_net:
                if existing_network.public == True:
                    logger.debug("public_network \"%s\" is available." % network.public_net)
                    found_public_net = True
                else:
                    raise InvalidInputException(
                        "network:\"%s\" is available but it is marked as private and not as public as defined." % network.public_net)
        if not network.private_net and not network.private_subnet and not network.public_net:
            logger.debug("Networks were not defined.")
        elif network.private_net and network.private_subnet and network.public_net:
            if found_private_net and found_subnet and found_public_net:
                logger.debug("All defined networks are available for network: %s" % network)
            if not found_private_net:
                raise NotFoundException("Not found private network: %s" % network)
            if not found_subnet:
                raise NotFoundException("Not found private subnet network: %s" % network)
            if not found_public_net:
                raise NotFoundException("Not found public network: %s" % network)
        elif network.private_net and network.private_subnet and not network.public_net:
            if found_private_net and found_subnet and not found_public_net:
                logger.debug("All defined networks are available for network: %s" % network)
            if not found_private_net:
                raise NotFoundException("Not found private network: %s" % network)
            if not found_subnet:
                raise NotFoundException("Not found private subnet network: %s" % network)
        elif not network.private_net and network.public_net:
            raise InvalidInputException("Private net is not defined but the public.")
        else:
            raise InvalidInputException("Error while checking networks.")
    except Exception, exc:
        exc.message = 'Network:\"%s\"->%s' % (network.name, exc.message)
        raise exc

def checkServiceUniqueness(service):
    db = DatabaseManager()
    # check uniqueness of service
    logger.debug("Check uniqueness of name of the service %s." % service.service_type)
    if service.service_type:
        for existing_service in db.get_all(Service):
            if service.service_type == existing_service.service_type and service != existing_service:
                raise NotUniqueException(
                    "Service:\"%s\" is already existing." % service.service_type)
    else:
        raise NotDefinedException("service_type is not defined.")

 def create(cls, service_args):
     try:
         conf = sys_util().get_sys_conf()
         service_manager = FactoryAgent().get_agent(conf["service_manager"])
         service = service_manager.create(service_args)
         checker = FactoryAgent().get_agent(conf["checker"])
         checker.check(service=service)
         db = DatabaseManager()
         db.persist(service)
     except Exception, msg:
         raise

 def create(cls, secgroup_args):
     _sec_rules = secgroup_args.get("rules")
     _new_sec_rules = []
     for _sec_rule_args in _sec_rules:
         _new_sec_rule = Rule(**_sec_rule_args)
         _new_sec_rules.append(_new_sec_rule)
     new_secgroup = SecurityGroup(name=secgroup_args.get('name'), rules=_new_sec_rules)
     conf = sys_util().get_sys_conf()
     checker = FactoryAgent().get_agent(conf['checker'])
     checker.check(security_group=new_secgroup)
     db = DatabaseManager()
     db.persist(new_secgroup)
     return new_secgroup

def checkServiceType(service_type):
    db = DatabaseManager()
    services = db.get_all(Service)
    found = False
    for service in services:
        if service.service_type == service_type:
            found = True
            logger.debug("service_type \"%s\" is available." % service_type)
    if not found:
        raise NotFoundException(
            "service_type:\"%s\" is not available. Available service_types:%s" % (
                service_type, [service.service_type for
                               service in services]))