def create_member(self, context, member): v = member['member'] tenant_id = self._get_tenant_id_for_create(context, v) member_id = '' if 'id' in v: member_id = v['id'] else: member_id = uuidutils.generate_uuid() try: with context.session.begin(subtransactions=True): # ensuring that pool exists self._get_resource(context, Pool, v['pool_id']) member_db = Member(id=member_id, tenant_id=tenant_id, pool_id=v['pool_id'], address=v['address'], protocol_port=v['protocol_port'], weight=v['weight'], admin_state_up=v['admin_state_up'], status=constants.ACTIVE) context.session.add(member_db) return self._make_member_dict(member_db) except exception.DBDuplicateEntry: raise loadbalancer.MemberExists( address=v['address'], port=v['protocol_port'], pool=v['pool_id'])
def create_firewall_rule(self, context, firewall_rule): LOG.debug(_("create_firewall_rule() called")) fwr = firewall_rule['firewall_rule'] tenant_id = self._get_tenant_id_for_create(context, fwr) src_port_min, src_port_max = self._get_min_max_ports_from_range( fwr['source_port']) dst_port_min, dst_port_max = self._get_min_max_ports_from_range( fwr['destination_port']) with context.session.begin(subtransactions=True): rule_id = '' if 'id' in fwr: rule_id = fwr['id'] else: rule_id = uuidutils.generate_uuid() fwr_db = FirewallRule(id=rule_id, tenant_id=tenant_id, name=fwr['name'], description=fwr['description'], shared=fwr['shared'], protocol=fwr['protocol'], ip_version=fwr['ip_version'], source_ip_address=fwr['source_ip_address'], destination_ip_address= fwr['destination_ip_address'], source_port_range_min=src_port_min, source_port_range_max=src_port_max, destination_port_range_min=dst_port_min, destination_port_range_max=dst_port_max, action=fwr['action'], enabled=fwr['enabled']) context.session.add(fwr_db) return self._make_firewall_rule_dict(fwr_db)
def create_dummy(self, context, dummy): d = dummy['dummy'] d['id'] = uuidutils.generate_uuid() self.dummys[d['id']] = d fanoutmsg = {} fanoutmsg.update({'method':'create_dummy','payload':self.dummys}) delta={} version = 0 delta[version] = fanoutmsg self.send_fanout(context,'call_consumer',delta) return d
def create_config_handle(self, context, config_handle): n = config_handle['config_handle'] tenant_id = self._get_tenant_id_for_create(context, n) with context.session.begin(subtransactions=True): config_handle = crd_config_handle(tenant_id=tenant_id, id=n.get('id') or uuidutils.generate_uuid(), name=n['name'], status=n['status'], slug=n['slug'], config_mode=n['config_mode']) context.session.add(config_handle) #### Delta Start ########################### data = self._make_config_handle_dict(config_handle) delta = {} data.update({'operation':'create'}) delta.update({'config_handles_delta': data}) self.create_config_handles_delta(context, delta) #### Delta End ########################### return self._make_config_handle_dict(config_handle)
def create_firewall_policy(self, context, firewall_policy): LOG.debug(_("create_firewall_policy() called")) fwp = firewall_policy['firewall_policy'] tenant_id = self._get_tenant_id_for_create(context, fwp) with context.session.begin(subtransactions=True): policy_id = '' if 'id' in fwp: policy_id = fwp['id'] else: policy_id = uuidutils.generate_uuid() fwp_db = FirewallPolicy(id=policy_id, tenant_id=tenant_id, name=fwp['name'], description=fwp['description'], shared=fwp['shared']) context.session.add(fwp_db) self._set_rules_for_policy(context, fwp_db, fwp['firewall_rules']) fwp_db.audited = fwp['audited'] return self._make_firewall_policy_dict(fwp_db)
def create_firewall(self, context, firewall): LOG.debug(_("create_firewall() called")) fw = firewall['firewall'] tenant_id = self._get_tenant_id_for_create(context, fw) with context.session.begin(subtransactions=True): fw_id = '' if 'id' in fw: fw_id = fw['id'] else: fw_id = uuidutils.generate_uuid() firewall_db = Firewall(id=fw_id, tenant_id=tenant_id, name=fw['name'], description=fw['description'], firewall_policy_id= fw['firewall_policy_id'], admin_state_up=fw['admin_state_up'], status=const.PENDING_CREATE) context.session.add(firewall_db) return self._make_firewall_dict(firewall_db)
def create_ofcluster_ofcontroller(self, context, params, cluster_id): """ Creiate a New Openflow Controller record """ # Check whether a row exists with this data in the table try: with context.session.begin(subtransactions=True): controller = OpenflowController(id=str(uuidutils.generate_uuid()), name=str(params['name']), ip_address=str(params['ip_address']), port=str(params['port']), cell=str(params['cell']), cluster_id=str(cluster_id), created_at=datetime.datetime.now(), updated_at=None, status='Active', deleted_at=None) context.session.add(controller) return self._make_controller_dict(controller) except BaseException: LOG.error("OF-Controller Already exist") return {}
def create_ofcluster(self, context, params): """ Create a New Openflow Cluster record """ # check any other cluster exists with the same name and key-cert db_record = self._check_ofcluster( context, params) if db_record is None: with context.session.begin(subtransactions=True): cluster = OpenflowCluster(id=str(uuidutils.generate_uuid()), name=str(params['name']), ca_cert_pem=str(params['ca_cert_path']), private_key_pem=str(params['private_key_path']), root_cert_pem=str(params['root_cert_path']), inter_cert_pem=str(params['inter_cert_path']), created_at=datetime.datetime.now(), updated_at=None, deleted_at=None) context.session.add(cluster) new_cluster = self._make_cluster_dict(cluster) return new_cluster else: return db_record
def create_ofcluster_ofcontroller_logicalswitch(self, context, params, cluster_id, controller_id=None): """ Create a New Switch record """ if self._check_ofcluster_ofcontroller_logicalswitch(context, params) is None: with context.session.begin(subtransactions=True): controller = OpenflowSwitch(id=str(uuidutils.generate_uuid()), datapath_id=str(params['datapath_id']), name=str(params['name']), ip_address=str(params['ip_address']), port=str(params['port']), certificate_pem=str(params['certificate_pem']), private_key_pem=str(params['private_key_pem']), created_at=datetime.datetime.now(), updated_at=None, deleted_at=None, cluster_id=cluster_id, controller_id=controller_id) context.session.add(controller) return self._make_switch_dict(controller) else: LOG.debug(_("Create Logical Switch failed." "Duplicate record found."))
def create_health_monitor(self, context, health_monitor): v = health_monitor['health_monitor'] tenant_id = self._get_tenant_id_for_create(context, v) monitor_id = '' if 'id' in v: monitor_id = v['id'] else: monitor_id = uuidutils.generate_uuid() with context.session.begin(subtransactions=True): # setting ACTIVE status since healthmon is shared DB object monitor_db = HealthMonitor(id=monitor_id, tenant_id=tenant_id, type=v['type'], delay=v['delay'], timeout=v['timeout'], max_retries=v['max_retries'], http_method=v['http_method'], url_path=v['url_path'], expected_codes=v['expected_codes'], admin_state_up=v['admin_state_up']) context.session.add(monitor_db) return self._make_health_monitor_dict(monitor_db)
def create_config_handles_delta(self, context, config_handles_delta): n = config_handles_delta['config_handles_delta'] LOG.error('Delta %s' % str(n)) tenant_id = self._get_tenant_id_for_create(context, n) user_id = context.user_id with context.session.begin(subtransactions=True): version_id = self.create_version(context, tenant_id) config_handles_delta = crd_config_handles_delta(tenant_id=tenant_id, id=uuidutils.generate_uuid(), config_handle_id = n['id'], name=n['name'], status=n['status'], slug=n['slug'], operation = n['operation'], user_id=user_id, logged_at=datetime.datetime.now(), version_id=version_id) context.session.add(config_handles_delta) payload = self._make_config_handles_delta_dict(config_handles_delta) method = n['operation']+"_config_handle" return self._make_config_handles_delta_dict(config_handles_delta)
def create_pool(self, context, pool): v = pool['pool'] tenant_id = self._get_tenant_id_for_create(context, v) pool_id = '' if 'id' in v: pool_id = v['id'] else: pool_id = uuidutils.generate_uuid() with context.session.begin(subtransactions=True): pool_db = Pool(id=pool_id, tenant_id=tenant_id, name=v['name'], description=v['description'], subnet_id=v['subnet_id'], protocol=v['protocol'], lb_method=v['lb_method'], admin_state_up=v['admin_state_up'], status=constants.ACTIVE) pool_db.stats = self._create_pool_stats(context, pool_db['id']) context.session.add(pool_db) return self._make_pool_dict(pool_db)
def create_vip(self, context, vip): core_db = network_db.CrdNetworkDb() v = vip['vip'] tenant_id = self._get_tenant_id_for_create(context, v) vip_id = '' if 'id' in v: vip_id = v['id'] else: vip_id = uuidutils.generate_uuid() with context.session.begin(subtransactions=True): if v['pool_id']: pool = self._get_resource(context, Pool, v['pool_id']) # validate that the pool has same tenant if pool['tenant_id'] != tenant_id: raise n_exc.NotAuthorized() # validate that the pool has same protocol if pool['protocol'] != v['protocol']: raise loadbalancer.ProtocolMismatch( vip_proto=v['protocol'], pool_proto=pool['protocol']) if pool['status'] == constants.PENDING_DELETE: raise loadbalancer.StateInvalid(state=pool['status'], id=pool['id']) else: pool = None vip_port_address = v['address'] port_id = None filters = {} filters['ip_address'] = [vip_port_address] vip_port = core_db.get_ports(context, filters=filters)[0] port_id = vip_port['id'] vip_db = Vip(id=vip_id, tenant_id=tenant_id, name=v['name'], description=v['description'], port_id=port_id, protocol_port=v['protocol_port'], protocol=v['protocol'], pool_id=v['pool_id'], connection_limit=v['connection_limit'], admin_state_up=v['admin_state_up'], status=constants.ACTIVE) session_info = v['session_persistence'] if session_info: s_p = self._create_session_persistence_db( session_info, vip_db['id']) vip_db.session_persistence = s_p try: context.session.add(vip_db) context.session.flush() except exception.DBDuplicateEntry: raise loadbalancer.VipExists(pool_id=v['pool_id']) # create a port to reserve address for IPAM #self._create_port_for_vip( # context, # vip_db, # v['subnet_id'], # v.get('address') #) if pool: pool['vip_id'] = vip_db['id'] return self._make_vip_dict(vip_db)
'default': '', 'is_visible': True}, 'tenant_id': {'allow_post': True, 'allow_put': False, 'validate': {'type:string': None}, 'required_by_policy': True, 'is_visible': True}, 'status': {'allow_post': True, 'allow_put': True, 'default': True, 'is_visible': True}, 'slug': {'allow_post': True, 'allow_put': True, 'default': '', 'is_visible': True}, 'config_mode': {'allow_post': True, 'allow_put': True, 'default': '', 'is_visible': True}, }, 'chainsets': { 'id': {'allow_post': True, 'allow_put': False, 'validate': {'type:regex': attr.UUID_PATTERN}, 'default': uuidutils.generate_uuid(), 'is_visible': True}, 'name': {'allow_post': True, 'allow_put': True, 'validate': {'type:string': None}, 'default': '', 'is_visible': True}, 'type': {'allow_post': False, 'allow_put': True, 'validate': {'type:string': None}, 'default': '-Mode', 'is_visible': True}, 'zonefull': {'allow_post': True, 'allow_put': True, 'default': True, 'convert_to': attr.convert_to_boolean, 'is_visible': True}, 'direction': {'allow_post': True, 'allow_put': True, 'default': '2',