def _get_server(self, attr_name): """lookup server info by name from context attr_name: either a name for a server created by yardstick or a dict with attribute name mapping when using external heat templates """ if isinstance(attr_name, collections.Mapping): node_name, cname = self.split_host_name(attr_name['name']) if cname is None or cname != self.name: return None # Create a dummy server instance for holding the *_ip attributes server = Server(node_name, self, {}) server.public_ip = self.stack.outputs.get( attr_name.get("public_ip_attr", object()), None) server.private_ip = self.stack.outputs.get( attr_name.get("private_ip_attr", object()), None) else: try: server = self._server_map[attr_name] except KeyError: attr_name_no_suffix = attr_name.split("-")[0] server = self._server_map.get(attr_name_no_suffix, None) if server is None: return None pkey = pkg_resources.resource_string( 'yardstick.resources', h_join('files/yardstick_key', self.name)).decode('utf-8') key_filename = pkg_resources.resource_filename( 'yardstick.resources', h_join('files/yardstick_key', self.name)) result = { "user": server.context.user, "pkey": pkey, "key_filename": key_filename, "private_ip": server.private_ip, "interfaces": server.interfaces, "routing_table": self.generate_routing_table(server), # empty IPv6 routing table "nd_route_tbl": [], # we want to save the contex name so we can generate pod.yaml "name": server.name, } # Target server may only have private_ip if server.public_ip: result["ip"] = server.public_ip return result
def init(self, attrs): '''initializes itself from the supplied arguments''' self.name = attrs["name"] if "user" in attrs: self._user = attrs["user"] if "heat_template" in attrs: self.template_file = attrs["heat_template"] self.heat_parameters = attrs.get("heat_parameters", None) return self.keypair_name = self.name + "-key" self.secgroup_name = self.name + "-secgroup" if "image" in attrs: self._image = attrs["image"] if "flavor" in attrs: self._flavor = attrs["flavor"] if "placement_groups" in attrs: for name, pgattrs in attrs["placement_groups"].items(): pg = PlacementGroup(name, self, pgattrs["policy"]) self.placement_groups.append(pg) for name, netattrs in attrs["networks"].items(): network = Network(name, self, netattrs) self.networks.append(network) for name, serverattrs in attrs["servers"].items(): server = Server(name, self, serverattrs) self.servers.append(server) self._server_map[server.dn] = server
def _get_server(self, attr_name): """lookup server info by name from context attr_name: either a name for a server created by yardstick or a dict with attribute name mapping when using external heat templates """ key_filename = pkg_resources.resource_filename( 'yardstick.resources', 'files/yardstick_key-' + get_short_key_uuid(self.key_uuid)) if isinstance(attr_name, collections.Mapping): cname = attr_name["name"].split(".")[1] if cname != self.name: return None public_ip = None private_ip = None if "public_ip_attr" in attr_name: public_ip = self.stack.outputs[attr_name["public_ip_attr"]] if "private_ip_attr" in attr_name: private_ip = self.stack.outputs[ attr_name["private_ip_attr"]] # Create a dummy server instance for holding the *_ip attributes server = Server(attr_name["name"].split(".")[0], self, {}) server.public_ip = public_ip server.private_ip = private_ip else: if attr_name not in self._server_map: return None server = self._server_map[attr_name] if server is None: return None result = { "user": server.context.user, "key_filename": key_filename, "private_ip": server.private_ip, "interfaces": server.interfaces, } # Target server may only have private_ip if server.public_ip: result["ip"] = server.public_ip return result
def _get_server(self, attr_name): '''lookup server info by name from context attr_name: either a name for a server created by yardstick or a dict with attribute name mapping when using external heat templates ''' key_filename = pkg_resources.resource_filename( 'yardstick.resources', 'files/yardstick_key') if type(attr_name) is dict: cname = attr_name["name"].split(".")[1] if cname != self.name: return None public_ip = None private_ip = None if "public_ip_attr" in attr_name: public_ip = self.stack.outputs[attr_name["public_ip_attr"]] if "private_ip_attr" in attr_name: private_ip = self.stack.outputs[ attr_name["private_ip_attr"]] # Create a dummy server instance for holding the *_ip attributes server = Server(attr_name["name"].split(".")[0], self, {}) server.public_ip = public_ip server.private_ip = private_ip else: if attr_name not in self._server_map: return None server = self._server_map[attr_name] if server is None: return None result = { "user": server.context.user, "key_filename": key_filename, "private_ip": server.private_ip } # Target server may only have private_ip if server.public_ip: result["ip"] = server.public_ip return result
def init(self, attrs): """Initializes itself from the supplied arguments""" super(HeatContext, self).init(attrs) self.check_environment() self._user = attrs.get("user") self.template_file = attrs.get("heat_template") self.shade_client = openstack_utils.get_shade_client() self.operator_client = openstack_utils.get_shade_operator_client() try: self.read_pod_file(attrs) except IOError: LOG.warning("No pod file specified. NVFi metrics will be disabled") self.heat_timeout = attrs.get("timeout", DEFAULT_HEAT_TIMEOUT) if self.template_file: self.heat_parameters = attrs.get("heat_parameters") return self.keypair_name = h_join(self.name, "key") self.secgroup_name = h_join(self.name, "secgroup") self.security_group = attrs.get("security_group") self._image = attrs.get("image") self._flavor = attrs.get("flavor") self.placement_groups = [ PlacementGroup(name, self, pg_attrs["policy"]) for name, pg_attrs in attrs.get("placement_groups", {}).items() ] self.server_groups = [ ServerGroup(name, self, sg_attrs["policy"]) for name, sg_attrs in attrs.get("server_groups", {}).items() ] # we have to do this first, because we are injecting external_network # into the dict sorted_networks = self.assign_external_network(attrs["networks"]) self.networks = OrderedDict((name, Network(name, self, net_attrs)) for name, net_attrs in sorted_networks) for name, server_attrs in sorted(attrs["servers"].items()): server = Server(name, self, server_attrs) self.servers.append(server) self._server_map[server.dn] = server self.attrs = attrs
def init(self, attrs): """Initializes itself from the supplied arguments""" super(HeatContext, self).init(attrs) self.check_environment() self._user = attrs.get("user") self.template_file = attrs.get("heat_template") self.heat_timeout = attrs.get("timeout", DEFAULT_HEAT_TIMEOUT) if self.template_file: self.heat_parameters = attrs.get("heat_parameters") return self.keypair_name = h_join(self.name, "key") self.secgroup_name = h_join(self.name, "secgroup") self._image = attrs.get("image") self._flavor = attrs.get("flavor") self.placement_groups = [ PlacementGroup(name, self, pg_attrs["policy"]) for name, pg_attrs in attrs.get("placement_groups", {}).items() ] self.server_groups = [ ServerGroup(name, self, sg_attrs["policy"]) for name, sg_attrs in attrs.get("server_groups", {}).items() ] # we have to do this first, because we are injecting external_network # into the dict sorted_networks = self.assign_external_network(attrs["networks"]) self.networks = OrderedDict((name, Network(name, self, net_attrs)) for name, net_attrs in sorted_networks) for name, server_attrs in sorted(attrs["servers"].items()): server = Server(name, self, server_attrs) self.servers.append(server) self._server_map[server.dn] = server self.attrs = attrs self.key_filename = ''.join([ consts.YARDSTICK_ROOT_PATH, 'yardstick/resources/files/yardstick_key-', self.name ]) # Permissions may have changed since creation; this can be fixed. If we # overwrite the file, we lose future access to VMs using this key. # As long as the file exists, even if it is unreadable, keep it intact if not os.path.exists(self.key_filename): SSH.gen_keys(self.key_filename)
def _get_server(self, attr_name): """lookup server info by name from context attr_name: either a name for a server created by yardstick or a dict with attribute name mapping when using external heat templates """ key_filename = pkg_resources.resource_filename( 'yardstick.resources', h_join('files/yardstick_key', get_short_key_uuid(self.key_uuid))) if isinstance(attr_name, collections.Mapping): node_name, cname = self.split_name(attr_name['name']) if cname is None or cname != self.name: return None # Create a dummy server instance for holding the *_ip attributes server = Server(node_name, self, {}) server.public_ip = self.stack.outputs.get( attr_name.get("public_ip_attr", object()), None) server.private_ip = self.stack.outputs.get( attr_name.get("private_ip_attr", object()), None) else: server = self._server_map.get(attr_name, None) if server is None: return None result = { "user": server.context.user, "key_filename": key_filename, "private_ip": server.private_ip, "interfaces": server.interfaces, "routing_table": self.generate_routing_table(server), # empty IPv6 routing table "nd_route_tbl": [], } # Target server may only have private_ip if server.public_ip: result["ip"] = server.public_ip return result
def init(self, attrs): # pragma: no cover """initializes itself from the supplied arguments""" self.name = attrs["name"] self._user = attrs.get("user") self.template_file = attrs.get("heat_template") if self.template_file: self.heat_parameters = attrs.get("heat_parameters") return self.keypair_name = self.name + "-key" self.secgroup_name = self.name + "-secgroup" self._image = attrs.get("image") self._flavor = attrs.get("flavor") self.heat_timeout = attrs.get("timeout", DEFAULT_HEAT_TIMEOUT) self.placement_groups = [PlacementGroup(name, self, pgattrs["policy"]) for name, pgattrs in attrs.get( "placement_groups", {}).items()] self.server_groups = [ServerGroup(name, self, sgattrs["policy"]) for name, sgattrs in attrs.get( "server_groups", {}).items()] # we have to do this first, because we are injecting external_network # into the dict sorted_networks = self.assign_external_network(attrs["networks"]) self.networks = OrderedDict( (name, Network(name, self, netattrs)) for name, netattrs in sorted_networks) for name, serverattrs in sorted(attrs["servers"].items()): server = Server(name, self, serverattrs) self.servers.append(server) self._server_map[server.dn] = server rsa_key = paramiko.RSAKey.generate(bits=2048, progress_func=None) rsa_key.write_private_key_file(self.key_filename) print("Writing %s ..." % self.key_filename) with open(self.key_filename + ".pub", "w") as pubkey_file: pubkey_file.write( "%s %s\n" % (rsa_key.get_name(), rsa_key.get_base64())) del rsa_key
def init(self, attrs): '''initializes itself from the supplied arguments''' self.name = attrs["name"] if "user" in attrs: self._user = attrs["user"] if "heat_template" in attrs: self.template_file = attrs["heat_template"] self.heat_parameters = attrs.get("heat_parameters", None) return self.keypair_name = self.name + "-key" self.secgroup_name = self.name + "-secgroup" if "image" in attrs: self._image = attrs["image"] if "flavor" in attrs: self._flavor = attrs["flavor"] if "placement_groups" in attrs: for name, pgattrs in attrs["placement_groups"].items(): pg = PlacementGroup(name, self, pgattrs["policy"]) self.placement_groups.append(pg) if "server_groups" in attrs: for name, sgattrs in attrs["server_groups"].items(): sg = ServerGroup(name, self, sgattrs["policy"]) self.server_groups.append(sg) for name, netattrs in attrs["networks"].items(): network = Network(name, self, netattrs) self.networks.append(network) for name, serverattrs in attrs["servers"].items(): server = Server(name, self, serverattrs) self.servers.append(server) self._server_map[server.dn] = server rsa_key = paramiko.RSAKey.generate(bits=2048, progress_func=None) rsa_key.write_private_key_file(self.key_filename) open(self.key_filename + ".pub", "w").write("%s %s\n" % (rsa_key.get_name(), rsa_key.get_base64())) del rsa_key
def init(self, attrs): self.check_environment() """initializes itself from the supplied arguments""" self.name = attrs["name"] self._user = attrs.get("user") self.template_file = attrs.get("heat_template") if self.template_file: self.heat_parameters = attrs.get("heat_parameters") return self.keypair_name = h_join(self.name, "key") self.secgroup_name = h_join(self.name, "secgroup") self._image = attrs.get("image") self._flavor = attrs.get("flavor") self.heat_timeout = attrs.get("timeout", DEFAULT_HEAT_TIMEOUT) self.placement_groups = [ PlacementGroup(name, self, pg_attrs["policy"]) for name, pg_attrs in attrs.get("placement_groups", {}).items() ] self.server_groups = [ ServerGroup(name, self, sg_attrs["policy"]) for name, sg_attrs in attrs.get("server_groups", {}).items() ] # we have to do this first, because we are injecting external_network # into the dict sorted_networks = self.assign_external_network(attrs["networks"]) self.networks = OrderedDict((name, Network(name, self, net_attrs)) for name, net_attrs in sorted_networks) for name, server_attrs in sorted(attrs["servers"].items()): server = Server(name, self, server_attrs) self.servers.append(server) self._server_map[server.dn] = server self.attrs = attrs SSH.gen_keys(self.key_filename)
def _get_server(self, attr_name): """lookup server info by name from context attr_name: either a name for a server created by yardstick or a dict with attribute name mapping when using external heat templates """ if isinstance(attr_name, collections.Mapping): node_name, cname = self.split_host_name(attr_name['name']) if cname is None or cname != self.name: return None # Create a dummy server instance for holding the *_ip attributes server = Server(node_name, self, {}) server.public_ip = self.stack.outputs.get( attr_name.get("public_ip_attr", object()), None) server.private_ip = self.stack.outputs.get( attr_name.get("private_ip_attr", object()), None) # Try to find interfaces for key, value in attr_name.get("interfaces", {}).items(): value["local_ip"] = server.private_ip for k in ["local_mac", "netmask", "gateway_ip"]: # Keep explicit None or missing entry as is value[k] = self.stack.outputs.get(value[k]) server.interfaces.update({key: value}) else: try: server = self._server_map[attr_name] except KeyError: attr_name_no_suffix = attr_name.split("-")[0] server = self._server_map.get(attr_name_no_suffix, None) if server is None: return None # Get the pkey if self.yardstick_gen_key_file: pkey = pkg_resources.resource_string( 'yardstick.resources', h_join('files/yardstick_key', self.name)).decode('utf-8') key_filename = pkg_resources.resource_filename('yardstick.resources', h_join('files/yardstick_key', self.name)) else: # make sure the file exists before attempting to open it if not os.path.exists(self.key_filename): LOG.error("The key_filename provided %s does not exist!", self.key_filename) else: try: pkey = open(self.key_filename, 'r').read().decode('utf-8') key_filename = self.key_filename except IOError: LOG.error("The key_filename provided (%s) is unreadable.", self.key_filename) result = { "user": server.context.user, "pkey": pkey, "key_filename": key_filename, "private_ip": server.private_ip, "interfaces": server.interfaces, "routing_table": self.generate_routing_table(server), # empty IPv6 routing table "nd_route_tbl": [], # we want to save the contex name so we can generate pod.yaml "name": server.name, } # Target server may only have private_ip if server.public_ip: result["ip"] = server.public_ip return result