def _stack_webhook(self, stack, output_key): """POST to the URL given in the output value identified by output_key. This can be used to scale stacks up and down, for instance. :param stack: stack to call a webhook on :param output_key: The name of the output to get the URL from :raises InvalidConfigException: if the output key is not found """ url = None for output in stack.outputs: if output["output_key"] == output_key: url = output["output_value"] break else: raise exceptions.InvalidConfigException( "No output key %(key)s found in stack %(id)s" % { "key": output_key, "id": stack.id }) platform_params = self.context["env"]["spec"]["existing@openstack"] verify = (platform_params["https_cacert"] if not platform_params["https_insecure"] else False) with atomic.ActionTimer(self, "heat.%s_webhook" % output_key): requests.post(url, verify=verify).raise_for_status()
def run(self, image, flavor, force_delete=False, actions=None, **kwargs): """Boot a server and run specified actions against it. Actions should be passed into the actions parameter. Available actions are 'hard_reboot', 'soft_reboot', 'stop_start', 'rescue_unrescue', 'pause_unpause', 'suspend_resume', 'lock_unlock' and 'shelve_unshelve'. Delete server after all actions were completed. :param image: image to be used to boot an instance :param flavor: flavor to be used to boot an instance :param force_delete: True if force_delete should be used :param actions: list of action dictionaries, where each action dictionary speicifes an action to be performed in the following format: {"action_name": <no_of_iterations>} :param kwargs: Optional additional arguments for server creation """ action_builder = self._bind_actions() actions = actions or [] try: action_builder.validate(actions) except jsonschema.exceptions.ValidationError as error: raise rally_exceptions.InvalidConfigException( "Invalid server actions configuration \'%(actions)s\' due to: " "%(error)s" % {"actions": str(actions), "error": str(error)}) server = self._boot_server(image, flavor, **kwargs) for action in action_builder.build_actions(actions, server): action() self._delete_server(server, force=force_delete)
def _create_lports(self, lswitch, lport_create_args=[], lport_amount=1, lport_ip_shift=1): LOG.info("create %d lports on lswitch %s" % \ (lport_amount, lswitch["name"])) self.RESOURCE_NAME_FORMAT = "lport_XXXXXX_XXXXXX" batch = lport_create_args.get("batch", lport_amount) port_security = lport_create_args.get("port_security", True) LOG.info("Create lports method: %s" % self.install_method) install_method = self.install_method network_cidr = lswitch.get("cidr", None) ip_addrs = None if network_cidr: end_ip = network_cidr.ip + lport_amount + lport_ip_shift if not end_ip in network_cidr: message = _( "Network %s's size is not big enough for %d lports.") raise exceptions.InvalidConfigException( message % (network_cidr, lport_amount)) ip_addrs = netaddr.iter_iprange(network_cidr.ip + lport_ip_shift, network_cidr.last) ovn_nbctl = self.controller_client("ovn-nbctl") ovn_nbctl.set_sandbox("controller-sandbox", install_method) ovn_nbctl.enable_batch_mode() base_mac = [i[:2] for i in self.task["uuid"].split('-')] base_mac[0] = str(hex(int(base_mac[0], 16) & 254)) base_mac[3:] = ['00'] * 3 flush_count = batch lports = [] for i in range(lport_amount): name = self.generate_random_name() lport = ovn_nbctl.lswitch_port_add(lswitch["name"], name) ip = str(ip_addrs.next()) if ip_addrs else "" mac = utils.get_random_mac(base_mac) ovn_nbctl.lport_set_addresses(name, [mac, ip]) if port_security: ovn_nbctl.lport_set_port_security(name, mac) lports.append(lport) flush_count -= 1 if flush_count < 1: ovn_nbctl.flush() flush_count = batch ovn_nbctl.flush() # ensure all commands be run ovn_nbctl.enable_batch_mode(False) return lports
def validate(self): super(LxcEngine, self).validate() if "start_lxc_network" not in self.config: return lxc_net = netaddr.IPNetwork(self.config["start_lxc_network"]) num_containers = self.config["containers_per_host"] if lxc_net.size - 3 < num_containers: message = _("Network size is not enough for %d hosts.") raise exceptions.InvalidConfigException(message % num_containers)
def _bind_ports_and_wait(self, lports, sandboxes, port_bind_args): port_bind_args = port_bind_args or {} wait_up = port_bind_args.get("wait_up", False) # "wait_sync" takes effect only if wait_up is True. # By default we wait for all HVs catching up with the change. wait_sync = port_bind_args.get("wait_sync", "hv") if wait_sync.lower() not in ['hv', 'sb', 'none']: raise exceptions.InvalidConfigException( _("Unknown value for wait_sync: %s. " "Only 'hv', 'sb' and 'none' are allowed.") % wait_sync) LOG.info("Bind lports method: %s" % self.install_method) self._bind_ports(lports, sandboxes, port_bind_args) if wait_up: self._wait_up_port(lports, wait_sync)
def _bind_ports(self, lports, sandboxes, port_bind_args): port_bind_args = port_bind_args or {} wait_up = port_bind_args.get("wait_up", False) # "wait_sync" takes effect only if wait_up is True. # By default we wait for all HVs catching up with the change. wait_sync = port_bind_args.get("wait_sync", "hv") if wait_sync.lower() not in ['hv', 'sb', 'none']: raise exceptions.InvalidConfigException(_( "Unknown value for wait_sync: %s. " "Only 'hv', 'sb' and 'none' are allowed.") % wait_sync) sandbox_num = len(sandboxes) lport_num = len(lports) lport_per_sandbox = (lport_num + sandbox_num - 1) / sandbox_num LOG.info("Bind lports method: %s" % self.install_method) install_method = self.install_method j = 0 for i in range(0, len(lports), lport_per_sandbox): lport_slice = lports[i:i+lport_per_sandbox] sandbox = sandboxes[j]["name"] farm = sandboxes[j]["farm"] ovs_vsctl = self.farm_clients(farm, "ovs-vsctl") ovs_vsctl.set_sandbox(sandbox, install_method) ovs_vsctl.enable_batch_mode() for lport in lport_slice: port_name = lport["name"] LOG.info("bind %s to %s on %s" % (port_name, sandbox, farm)) ovs_vsctl.add_port('br-int', port_name) ovs_vsctl.db_set('Interface', port_name, ('external_ids', {"iface-id":port_name, "iface-status":"active"}), ('admin_state', 'up')) ovs_vsctl.flush() j += 1 if wait_up: self._wait_up_port(lports, wait_sync, install_method)
def boot_and_bounce_server(self, image_id, flavor_id, **kwargs): """Tests booting a server then performing stop/start or hard/soft reboot a number of times. """ action_builder = self._bind_actions() actions = kwargs.get('actions', []) try: action_builder.validate(actions) except jsonschema.exceptions.ValidationError as error: raise rally_exceptions.InvalidConfigException( "Invalid server actions configuration \'%(actions)s\' due to: " "%(error)s" % { 'actions': str(actions), 'error': str(error) }) server = self._boot_server(self._generate_random_name(16), image_id, flavor_id, **kwargs) for action in action_builder.build_actions(actions, server): action() self._delete_server(server)
def _stack_webhook(self, stack, output_key): """POST to the URL given in the output value identified by output_key. This can be used to scale stacks up and down, for instance. :param stack: stack to call a webhook on :param output_key: The name of the output to get the URL from :raises InvalidConfigException: if the output key is not found """ url = None for output in stack.outputs: if output["output_key"] == output_key: url = output["output_value"] break else: raise exceptions.InvalidConfigException( "No output key %(key)s found in stack %(id)s" % {"key": output_key, "id": stack.id}) with atomic.ActionTimer(self, "heat.%s_webhook" % output_key): requests.post(url).raise_for_status()
def boot_and_bounce_server(self, image, flavor, **kwargs): """Test booting a server with further performing specified actions. Actions should be passed into kwargs. Available actions are 'hard_reboot', 'soft_reboot', 'stop_start' and 'rescue_unrescue'. Delete server after all actions. """ action_builder = self._bind_actions() actions = kwargs.get('actions', []) try: action_builder.validate(actions) except jsonschema.exceptions.ValidationError as error: raise rally_exceptions.InvalidConfigException( "Invalid server actions configuration \'%(actions)s\' due to: " "%(error)s" % { 'actions': str(actions), 'error': str(error) }) server = self._boot_server(self._generate_random_name(), image, flavor, **kwargs) for action in action_builder.build_actions(actions, server): action() self._delete_server(server)
def _do_create_address_set_addr(self, address_set_id, addresses_per_address_set=1, addresses_start_cidr='10.0.0.0/8', addresses_create_bulk=False, addresses_create_batch=1): addr_cidr = netaddr.IPNetwork(addresses_start_cidr) end_ip = addr_cidr.ip + addresses_per_address_set if not end_ip in addr_cidr: message = _( "Address CIDR %s's size is not big enough for %d addresses.") raise exceptions.InvalidConfigException( message % (addresses_start_cidr, addresses_per_address_set)) addrs_list = [] for ip in netaddr.iter_iprange(addr_cidr.ip + 1, end_ip): addrs_list.append({'addr': {'address': str(ip)}}) for addrs in common_utils.chunks(addrs_list, addresses_create_batch): if addresses_create_bulk: self._create_address_set_addr_bulk(address_set_id, addrs) else: self._create_address_set_addrs(address_set_id, addrs)
def _create_sandbox(self, sandbox_create_args): """ :param sandbox_create_args from task config file """ print("create sandbox") amount = sandbox_create_args.get("amount", 1) batch = sandbox_create_args.get("batch", 1) farm = sandbox_create_args.get("farm") controller_ip = self.context["controller"]["ip"] start_cidr = sandbox_create_args.get("start_cidr") net_dev = sandbox_create_args.get("net_dev", "eth0") tag = sandbox_create_args.get("tag", "") LOG.info("-------> Create sandbox method: %s" % self.install_method) install_method = self.install_method if controller_ip == None: raise exceptions.NoSuchConfigField(name="controller_ip") sandbox_cidr = netaddr.IPNetwork(start_cidr) end_ip = sandbox_cidr.ip + amount if not end_ip in sandbox_cidr: message = _( "Network %s's size is not big enough for %d sandboxes.") raise exceptions.InvalidConfigException(message % (start_cidr, amount)) sandbox_hosts = netaddr.iter_iprange(sandbox_cidr.ip, sandbox_cidr.last) ssh = self.farm_clients(farm) sandboxes = {} batch_left = min(batch, amount) i = 0 while i < amount: i += batch_left host_ip_list = [] while batch_left > 0: host_ip_list.append(str(sandbox_hosts.next())) batch_left -= 1 cmds = [] for host_ip in host_ip_list: cmd = "./ovs-sandbox.sh --ovn --controller-ip %s \ --host-ip %s/%d --device %s" % \ (controller_ip, host_ip, sandbox_cidr.prefixlen, net_dev) cmds.append(cmd) sandboxes["sandbox-%s" % host_ip] = tag if install_method == "docker": print "Do not run ssh; sandbox installed by ansible-docker" elif install_method == "physical": print "Do not run ssh; sandbox installed on physical test bed" elif install_method == "sandbox": self._do_create_sandbox(ssh, cmds) else: print "Invalid install method for controller" exit(1) batch_left = min(batch, amount - i) if batch_left <= 0: break self._add_sandbox_resource(farm, sandboxes) return sandboxes