def test__get_default_configuration_file_name_from_type_positive(self):
"""Test for _get_default_configuration_file_name_from_type method positive result."""
_get_default_configuration_file_name_from_type("agent")
_get_default_configuration_file_name_from_type("connection")
_get_default_configuration_file_name_from_type("protocol")
_get_default_configuration_file_name_from_type("skill")
_get_default_configuration_file_name_from_type("contract")
def fingerprint_package(package_dir: Path,
package_type: Union[str, PackageType]) -> None:
"""
Fingerprint components of an item.
:param ctx: the context.
:param item_type: the item type.
:param item_public_id: the item public id.
:return: None
"""
package_type = PackageType(package_type)
item_type = str(package_type)
default_config_file_name = _get_default_configuration_file_name_from_type(
item_type)
config_loader = ConfigLoader.from_configuration_type(item_type)
config_file_path = Path(package_dir, default_config_file_name)
config = config_loader.load(open_file(config_file_path))
if not package_dir.exists():
# we only permit non-vendorized packages to be fingerprinted
raise ValueError("Package not found at path {}".format(package_dir))
fingerprints_dict = _compute_fingerprint(
package_dir, ignore_patterns=config.fingerprint_ignore_patterns
) # type: Dict[str, str]
# Load item specification yaml file and add fingerprints
config.fingerprint = fingerprints_dict
config_loader.dump(config, open_file(config_file_path, "w"))
def _get_item_details(ctx, item_type) -> List[Dict]:
"""Return a list of item details, given the item type."""
result = []
item_type_plural = item_type + "s"
public_ids = getattr(ctx.agent_config,
item_type_plural) # type: Set[PublicId]
default_file_name = _get_default_configuration_file_name_from_type(
item_type)
for public_id in public_ids:
# first, try to retrieve the item from the vendor directory.
configuration_filepath = Path(
ctx.cwd,
"vendor",
public_id.author,
item_type_plural,
public_id.name,
default_file_name,
)
# otherwise, if it does not exist, retrieve the item from the agent custom packages
if not configuration_filepath.exists():
configuration_filepath = Path(ctx.cwd, item_type_plural,
public_id.name, default_file_name)
configuration_loader = ConfigLoader.from_configuration_type(
PackageType(item_type))
details = retrieve_details(public_id.name, configuration_loader,
str(configuration_filepath))
result.append(details)
return result
def _validate_config_consistency(ctx: Context):
"""
Validate fingerprints for every agent component.
:param ctx: the context
:raise ValueError: if there is a missing configuration file.
or if the configuration file is not valid.
or if the fingerprints do not match
"""
packages_public_ids_to_types = dict([
*map(lambda x: (x, PackageType.PROTOCOL), ctx.agent_config.protocols),
*map(
lambda x: (x, PackageType.CONNECTION),
ctx.agent_config.connections,
),
*map(lambda x: (x, PackageType.SKILL), ctx.agent_config.skills),
*map(lambda x: (x, PackageType.CONTRACT), ctx.agent_config.contracts),
]) # type: Dict[PublicId, PackageType]
for public_id, item_type in packages_public_ids_to_types.items():
# find the configuration file.
try:
# either in vendor/ or in personal packages.
# we give precedence to custom agent components (i.e. not vendorized).
package_directory = Path(item_type.to_plural(), public_id.name)
is_vendor = False
if not package_directory.exists():
package_directory = Path("vendor", public_id.author,
item_type.to_plural(), public_id.name)
is_vendor = True
# we fail if none of the two alternative works.
enforce(package_directory.exists(),
"Package directory does not exist!")
loader = ConfigLoaders.from_package_type(item_type)
config_file_name = _get_default_configuration_file_name_from_type(
item_type)
configuration_file_path = package_directory / config_file_name
enforce(
configuration_file_path.exists(),
"Configuration file path does not exist!",
)
except Exception:
raise ValueError("Cannot find {}: '{}'".format(
item_type.value, public_id))
# load the configuration file.
try:
package_configuration = loader.load(
configuration_file_path.open("r"))
except ValidationError as e:
raise ValueError("{} configuration file not valid: {}".format(
item_type.value.capitalize(), str(e)))
_check_aea_version(package_configuration)
_compare_fingerprints(package_configuration, package_directory,
is_vendor, item_type)
def _add_item(click_context, item_type, item_public_id) -> None:
"""
Add an item.
:param click_context: the click context.
:param item_type: the item type.
:param item_public_id: the item public id.
:return: None
"""
ctx = cast(Context, click_context.obj)
agent_name = cast(str, ctx.agent_config.agent_name)
item_type_plural = item_type + "s"
supported_items = getattr(ctx.agent_config, item_type_plural)
is_local = ctx.config.get("is_local")
click.echo("Adding {} '{}' to the agent '{}'...".format(
item_type, item_public_id, agent_name))
# check if we already have an item with the same name
logger.debug("{} already supported by the agent: {}".format(
item_type_plural.capitalize(), supported_items))
if _is_item_present(item_type, item_public_id, ctx):
logger.error("A {} with id '{}/{}' already exists. Aborting...".format(
item_type, item_public_id.author, item_public_id.name))
sys.exit(1)
# find and add protocol
if item_public_id in [DEFAULT_CONNECTION, DEFAULT_PROTOCOL, DEFAULT_SKILL]:
package_path = _find_item_in_distribution(ctx, item_type,
item_public_id)
_copy_package_directory(ctx, package_path, item_type,
item_public_id.name, item_public_id.author)
elif is_local:
package_path = _find_item_locally(ctx, item_type, item_public_id)
_copy_package_directory(ctx, package_path, item_type,
item_public_id.name, item_public_id.author)
else:
package_path = fetch_package(item_type,
public_id=item_public_id,
cwd=ctx.cwd)
if item_type in {"connection", "skill"}:
configuration_file_name = _get_default_configuration_file_name_from_type(
item_type)
configuration_path = package_path / configuration_file_name
configuration_loader = ConfigLoader.from_configuration_type(
ConfigurationType(item_type))
item_configuration = configuration_loader.load(
configuration_path.open())
_add_protocols(click_context, item_configuration.protocols)
# add the item to the configurations.
logger.debug("Registering the {} into {}".format(item_type,
DEFAULT_AEA_CONFIG_FILE))
supported_items.add(item_public_id)
ctx.agent_loader.dump(
ctx.agent_config,
open(os.path.join(ctx.cwd, DEFAULT_AEA_CONFIG_FILE), "w"))
def find_item_locally(
ctx: Context, item_type: str,
item_public_id: PublicId) -> Tuple[Path, ComponentConfiguration]:
"""
Find an item in the local registry.
:param ctx: the CLI context.
:param item_type: the type of the item to load. One of: protocols, connections, skills
:param item_public_id: the public id of the item to find.
:return: tuple of path to the package directory (either in registry or in aea directory) and component configuration
:raises SystemExit: if the search fails.
"""
item_type_plural = item_type + "s"
item_name = item_public_id.name
# check in registry
registry_path = (os.path.join(ctx.cwd, ctx.agent_config.registry_path)
if ctx.registry_path is None else ctx.registry_path)
package_path = Path(registry_path, item_public_id.author, item_type_plural,
item_name)
config_file_name = _get_default_configuration_file_name_from_type(
item_type)
item_configuration_filepath = package_path / config_file_name
if not item_configuration_filepath.exists():
raise click.ClickException("Cannot find {}: '{}'.".format(
item_type, item_public_id))
# try to load the item configuration file
try:
item_configuration_loader = ConfigLoader.from_configuration_type(
PackageType(item_type))
with item_configuration_filepath.open() as fp:
item_configuration = item_configuration_loader.load(fp)
except ValidationError as e:
raise click.ClickException(
"{} configuration file not valid: {}".format(
item_type.capitalize(), str(e)))
# check that the configuration file of the found package matches the expected author and version.
version = item_configuration.version
author = item_configuration.author
if item_public_id.author != author or (
not item_public_id.package_version.is_latest
and item_public_id.version != version):
raise click.ClickException(
"Cannot find {} with author and version specified.".format(
item_type))
return package_path, item_configuration
def _find_item_locally(ctx, item_type, item_public_id) -> Path:
"""
Find an item in the registry or in the AEA directory.
:param ctx: the CLI context.
:param item_type: the type of the item to load. One of: protocols, connections, skills
:param item_public_id: the public id of the item to find.
:return: path to the package directory (either in registry or in aea directory).
:raises SystemExit: if the search fails.
"""
item_type_plural = item_type + "s"
item_name = item_public_id.name
# check in registry
registry_path = os.path.join(ctx.cwd, ctx.agent_config.registry_path)
package_path = Path(registry_path, item_public_id.author, item_type_plural,
item_name)
config_file_name = _get_default_configuration_file_name_from_type(
item_type)
item_configuration_filepath = package_path / config_file_name
if not item_configuration_filepath.exists():
# then check in aea dir
registry_path = AEA_DIR
package_path = Path(registry_path, item_type_plural, item_name)
item_configuration_filepath = package_path / config_file_name
if not item_configuration_filepath.exists():
logger.error("Cannot find {}: '{}'.".format(
item_type, item_public_id))
sys.exit(1)
# try to load the item configuration file
try:
item_configuration_loader = ConfigLoader.from_configuration_type(
ConfigurationType(item_type))
item_configuration = item_configuration_loader.load(
item_configuration_filepath.open())
except ValidationError as e:
logger.error("{} configuration file not valid: {}".format(
item_type.capitalize(), str(e)))
sys.exit(1)
# check that the configuration file of the found package matches the expected author and version.
version = item_configuration.version
author = item_configuration.author
if item_public_id.author != author or item_public_id.version != version:
logger.error(
"Cannot find {} with author and version specified.".format(
item_type))
sys.exit(1)
return package_path
def load_agent_config(cls, agent_name: str) -> AgentConfig:
"""Load agent configuration."""
if agent_name not in cls.agents:
raise AEATestingException(
f"Cannot find agent '{agent_name}' in the current test case."
)
loader = ConfigLoaders.from_package_type(PackageType.AGENT)
config_file_name = _get_default_configuration_file_name_from_type(
PackageType.AGENT
)
configuration_file_path = Path(cls.t, agent_name, config_file_name)
with open_file(configuration_file_path) as file_input:
agent_config = loader.load(file_input)
return agent_config
def load_item_config(item_type: str, package_path: Path) -> PackageConfiguration:
"""
Load item configuration.
:param item_type: type of item.
:param package_path: path to package from which config should be loaded.
:return: configuration object.
"""
configuration_file_name = _get_default_configuration_file_name_from_type(item_type)
configuration_path = package_path / configuration_file_name
configuration_loader = ConfigLoader.from_configuration_type(PackageType(item_type))
with open_file(configuration_path) as file_input:
item_config = configuration_loader.load(file_input)
return item_config
def find_item_in_distribution( # pylint: disable=unused-argument
ctx: Context, item_type: str, item_public_id: PublicId) -> Path:
"""
Find an item in the AEA directory.
:param ctx: the CLI context.
:param item_type: the type of the item to load. One of: protocols, connections, skills
:param item_public_id: the public id of the item to find.
:return: path to the package directory (either in registry or in aea directory).
:raises SystemExit: if the search fails.
"""
item_type_plural = item_type + "s"
item_name = item_public_id.name
# check in aea dir
registry_path = AEA_DIR
package_path = Path(registry_path, item_type_plural, item_name)
config_file_name = _get_default_configuration_file_name_from_type(
item_type)
item_configuration_filepath = package_path / config_file_name
if not item_configuration_filepath.exists():
raise click.ClickException("Cannot find {}: '{}'.".format(
item_type, item_public_id))
# try to load the item configuration file
try:
item_configuration_loader = ConfigLoader.from_configuration_type(
PackageType(item_type))
with item_configuration_filepath.open() as fp:
item_configuration = item_configuration_loader.load(fp)
except ValidationError as e:
raise click.ClickException(
"{} configuration file not valid: {}".format(
item_type.capitalize(), str(e)))
# check that the configuration file of the found package matches the expected author and version.
version = item_configuration.version
author = item_configuration.author
if item_public_id.author != author or (
not item_public_id.package_version.is_latest
and item_public_id.version != version):
raise click.ClickException(
"Cannot find {} with author and version specified.".format(
item_type))
return package_path # pragma: no cover
def dump_item_config(package_configuration: PackageConfiguration,
package_path: Path) -> None:
"""
Dump item configuration.
:param package_configuration: the package configuration.
:param package_path: path to package from which config should be dumped.
:return: None
"""
configuration_file_name = _get_default_configuration_file_name_from_type(
package_configuration.package_type)
configuration_path = package_path / configuration_file_name
configuration_loader = ConfigLoader.from_configuration_type(
package_configuration.package_type)
with configuration_path.open("w") as file_output:
configuration_loader.dump(package_configuration,
file_output) # type: ignore
def _get_item_dependencies(item_type, public_id: PublicId) -> Dependencies:
"""Get the dependencies from item type and public id."""
item_type_plural = item_type + "s"
default_config_file_name = _get_default_configuration_file_name_from_type(
item_type)
path = Path(
"vendor",
public_id.author,
item_type_plural,
public_id.name,
default_config_file_name,
)
if not path.exists():
path = Path(item_type_plural, public_id.name,
default_config_file_name)
config_loader = ConfigLoader.from_configuration_type(item_type)
config = config_loader.load(path.open())
deps = cast(Dependencies, config.dependencies)
return deps
def fingerprint_item(ctx: Context, item_type: str, item_public_id: PublicId) -> None:
"""
Fingerprint components of an item.
:param ctx: the context.
:param item_type: the item type.
:param item_public_id: the item public id.
:return: None
"""
item_type_plural = item_type + "s"
click.echo(
"Fingerprinting {} components of '{}' ...".format(item_type, item_public_id)
)
# create fingerprints
package_dir = Path(ctx.cwd, item_type_plural, item_public_id.name)
try:
default_config_file_name = _get_default_configuration_file_name_from_type(
item_type
)
config_loader = ConfigLoader.from_configuration_type(item_type)
config_file_path = Path(package_dir, default_config_file_name)
config = config_loader.load(config_file_path.open())
if not package_dir.exists():
# we only permit non-vendorized packages to be fingerprinted
raise click.ClickException(
"Package not found at path {}".format(package_dir)
)
fingerprints_dict = _compute_fingerprint(
package_dir, ignore_patterns=config.fingerprint_ignore_patterns
) # type: Dict[str, str]
# Load item specification yaml file and add fingerprints
config.fingerprint = fingerprints_dict
config_loader.dump(config, open(config_file_path, "w"))
except Exception as e:
raise click.ClickException(str(e))
