How to use

RepositoryMetadataStore

in

com.thoughtworks.go.plugin.access.packagematerial

private void handlePackageRepositoryProperties(List<String> list) {
  PackageConfigurations metadata = RepositoryMetadataStore.getInstance().getMetadata(pluginId());
  for (ConfigurationProperty configurationProperty : packageRepository.getConfiguration()) {
    handleProperty(list, metadata, configurationProperty);
  }
}

@Test
public void shouldPopulateDataCorrectly() throws Exception {
  PackageConfigurations repositoryConfigurationPut = new PackageConfigurations();
  RepositoryMetadataStore.getInstance().addMetadataFor("plugin-id", repositoryConfigurationPut);
  assertThat(RepositoryMetadataStore.getInstance().getMetadata("plugin-id"), is(repositoryConfigurationPut));
}

@Test
public void shouldGetAllPluginIds() throws Exception {
  RepositoryMetadataStore metadataStore = RepositoryMetadataStore.getInstance();
  metadataStore.addMetadataFor("plugin1", new PackageConfigurations());
  metadataStore.addMetadataFor("plugin2", new PackageConfigurations());
  metadataStore.addMetadataFor("plugin3", new PackageConfigurations());
  assertThat(metadataStore.getPlugins().size(), is(3));
  assertThat(metadataStore.getPlugins().contains("plugin1"), is(true));
  assertThat(metadataStore.getPlugins().contains("plugin2"), is(true));
  assertThat(metadataStore.getPlugins().contains("plugin3"), is(true));
}

  public static void clear() {
    List<String> plugins = RepositoryMetadataStore.getInstance().getPlugins();
    for (String pluginId : plugins) {
      RepositoryMetadataStore.getInstance().removeMetadata(pluginId);
      PackageMetadataStore.getInstance().removeMetadata(pluginId);
    }
  }
}

private boolean doesPluginExist() {
  return packageRepository != null && RepositoryMetadataStore.getInstance().hasPlugin(pluginId());
}

@Test
public void shouldReturnSomethingMoreSaneForToString() throws Exception {
  PackageMaterial material = MaterialsMother.packageMaterial();
  RepositoryMetadataStore.getInstance().addMetadataFor(material.getPluginId(), new PackageConfigurations());
  PackageMetadataStore.getInstance().addMetadataFor(material.getPluginId(), new PackageConfigurations());
  assertThat(material.toString(), is("'PackageMaterial{Repository: [k1=repo-v1, k2=repo-v2] - Package: [k3=package-v1]}'"));
}

@Test
public void shouldAnswerIfKeyHasGivenOption() throws Exception {
  PackageConfigurations repositoryConfigurationPut = new PackageConfigurations();
  repositoryConfigurationPut.add(new PackageConfiguration("key-one").with(PackageConfiguration.SECURE, true).with(PackageConfiguration.REQUIRED, true));
  repositoryConfigurationPut.add(new PackageConfiguration("key-two"));
  RepositoryMetadataStore metadataStore = RepositoryMetadataStore.getInstance();
  metadataStore.addMetadataFor("plugin-id", repositoryConfigurationPut);
  assertThat(metadataStore.hasOption("plugin-id", "key-one", PackageConfiguration.SECURE),is(true));
  assertThat(metadataStore.hasOption("plugin-id", "key-one", PackageConfiguration.REQUIRED),is(true));
  assertThat(metadataStore.hasOption("plugin-id", "key-one", PackageConfiguration.PART_OF_IDENTITY),is(true));
  assertThat(metadataStore.hasOption("plugin-id", "key-two", PackageConfiguration.SECURE),is(false));
  assertThat(metadataStore.hasOption("plugin-id", "key-two", PackageConfiguration.REQUIRED),is(true));
  assertThat(metadataStore.hasOption("plugin-id", "key-two", PackageConfiguration.PART_OF_IDENTITY),is(true));
}

  @Test
  public void shouldBeAbleToCheckIfPluginExists() throws Exception {
    RepositoryMetadataStore metadataStore = RepositoryMetadataStore.getInstance();

    PackageConfigurations repositoryConfigurationPut = new PackageConfigurations();
    metadataStore.addMetadataFor("plugin-id", repositoryConfigurationPut);

    assertThat(metadataStore.hasPlugin("plugin-id"), is(true));
    assertThat(metadataStore.hasPlugin("some-plugin-which-does-not-exist"), is(false));
  }
}

@PostConstruct
public void applyPackagePluginMetadata() {
  String pluginId = pluginConfiguration.getId();
  for (ConfigurationProperty configurationProperty : configuration) {
    RepositoryMetadataStore repositoryMetadataStore = RepositoryMetadataStore.getInstance();
    if (repositoryMetadataStore.getMetadata(pluginId) != null) {
      boolean isSecureProperty = repositoryMetadataStore.hasOption(pluginId, configurationProperty.getConfigurationKey().getName(), PackageConfiguration.SECURE);
      configurationProperty.handleSecureValueConfiguration(isSecureProperty);
    }
  }
  for (PackageDefinition packageDefinition : packages) {
    packageDefinition.applyPackagePluginMetadata(pluginId);
  }
}

@Before
public void setUp() throws Exception {
  pluginDescriptor = new GoPluginDescriptor("plugin-id", "1.0", null, null, null, true);
  pluginManager = mock(PluginManager.class);
  packageRepositoryExtension = mock(PackageRepositoryExtension.class);
  metadataLoader = new PackageMaterialMetadataLoader(pluginManager, packageRepositoryExtension);
  RepositoryMetadataStore.getInstance().removeMetadata(pluginDescriptor.id());
  PackageMetadataStore.getInstance().removeMetadata(pluginDescriptor.id());
}

@Autowired
public PackageRepositoryService(PluginManager pluginManager, PackageRepositoryExtension packageRepositoryExtension, GoConfigService goConfigService, SecurityService securityService,
                EntityHashingService entityHashingService) {
  this.pluginManager = pluginManager;
  this.packageRepositoryExtension = packageRepositoryExtension;
  this.goConfigService = goConfigService;
  this.securityService = securityService;
  this.entityHashingService = entityHashingService;
  repositoryMetadataStore = RepositoryMetadataStore.getInstance();
}

public void addConfigurations(List<ConfigurationProperty> configurations) {
  ConfigurationPropertyBuilder builder = new ConfigurationPropertyBuilder();
  for (ConfigurationProperty property : configurations) {
    RepositoryConfiguration repositoryMetadata = RepositoryMetadataStore.getInstance().getRepositoryMetadata(pluginConfiguration.getId());
    if (isValidPluginConfiguration(property.getConfigKeyName(), repositoryMetadata)) {
      configuration.add(builder.create(property.getConfigKeyName(), property.getConfigValue(), property.getEncryptedValue(),
          repositoryPropertyFor(property.getConfigKeyName(), repositoryMetadata).getOption(Property.SECURE)));
    }
    else {
      configuration.add(property);
    }
  }
}

  public static void clearSingletons() {
    AnalyticsMetadataStore.instance().clear();
    ArtifactMetadataStore.instance().clear();
    AuthorizationMetadataStore.instance().clear();
    ConfigRepoMetadataStore.instance().clear();
    ElasticAgentMetadataStore.instance().clear();
    NewSCMMetadataStore.instance().clear();
    NotificationMetadataStore.instance().clear();
    PackageMaterialMetadataStore.instance().clear();
    PluggableTaskMetadataStore.instance().clear();

    new CachingSubjectDnX509PrincipalExtractor().getCache().removeAll();

    //
    SessionUtils.unsetCurrentUser();

    //
    PackageMetadataStore.getInstance().clear();
    PluggableTaskConfigStore.store().clear();
    PluginSettingsMetadataStore.getInstance().clear();
    RepositoryMetadataStore.getInstance().clear();
    SCMMetadataStore.getInstance().clear();
  }
}

void fetchRepositoryAndPackageMetaData(GoPluginDescriptor pluginDescriptor) {
  try {
    RepositoryConfiguration repositoryConfiguration = packageRepositoryExtension.getRepositoryConfiguration(pluginDescriptor.id());
    com.thoughtworks.go.plugin.api.material.packagerepository.PackageConfiguration packageConfiguration = packageRepositoryExtension.getPackageConfiguration(pluginDescriptor.id());
    if (repositoryConfiguration == null) {
      throw new RuntimeException(format("Plugin[%s] returned null repository configuration", pluginDescriptor.id()));
    }
    if (packageConfiguration == null) {
      throw new RuntimeException(format("Plugin[%s] returned null package configuration", pluginDescriptor.id()));
    }
    repositoryMetadataStore.addMetadataFor(pluginDescriptor.id(), new PackageConfigurations(repositoryConfiguration));
    packageMetadataStore.addMetadataFor(pluginDescriptor.id(), new PackageConfigurations(packageConfiguration));
  } catch (GoPluginFrameworkException e) {
    LOGGER.error("Failed to fetch package metadata for plugin : {}", pluginDescriptor.id(), e);
  }
}

  public RepositoryConfiguration getRepositoryMetadata(String pluginId) {

    PackageConfigurations metadata = repositoryMetadataStore.getMetadata(pluginId);
    if (metadata != null) {
      return metadata.getRepositoryConfiguration();
    }
    return null;
  }
}

  @Override
  public void pluginUnLoaded(GoPluginDescriptor pluginDescriptor) {
    repositoryMetadataStore.removeMetadata(pluginDescriptor.id());
    packageMetadataStore.removeMetadata(pluginDescriptor.id());
  }
}

public boolean validatePluginId(PackageRepository packageRepository) {
  String pluginId = packageRepository.getPluginConfiguration().getId();
  if (isEmpty(pluginId)) {
    packageRepository.getPluginConfiguration().errors().add(PluginConfiguration.ID, "Please select package repository plugin");
    return false;
  }
  for (String currentPluginId : repositoryMetadataStore.getPlugins()) {
    if (currentPluginId.equals(pluginId)) {
      GoPluginDescriptor pluginDescriptor = pluginManager.getPluginDescriptorFor(pluginId);
      packageRepository.getPluginConfiguration().setVersion(pluginDescriptor.version());
      return true;
    }
  }
  packageRepository.getPluginConfiguration().errors().add(PluginConfiguration.ID, "Invalid plugin id");
  return false;
}

void performPluginValidationsFor(final PackageRepository packageRepository) {
  if (!validatePluginId(packageRepository)) {
    return;
  }
  for (ConfigurationProperty configurationProperty : packageRepository.getConfiguration()) {
    String key = configurationProperty.getConfigurationKey().getName();
    String pluginId = packageRepository.getPluginConfiguration().getId();
    if (repositoryMetadataStore.hasOption(pluginId, key, PackageConfiguration.REQUIRED)) {
      if (configurationProperty.getValue().isEmpty()) {
        configurationProperty.addErrorAgainstConfigurationValue("This field is required");
      }
    }
  }
  ValidationResult validationResult = packageRepositoryExtension.isRepositoryConfigurationValid(packageRepository.getPluginConfiguration().getId(), populateConfiguration(packageRepository.getConfiguration()));
  for (ValidationError error : validationResult.getErrors()) {
    packageRepository.addConfigurationErrorFor(error.getKey(), error.getMessage());
  }
}

@Test
public void shouldConvertKeysToLowercaseInGetConfigForDisplay() throws Exception {
  RepositoryMetadataStore.getInstance().addMetadataFor("some-plugin", new PackageConfigurations());
  PackageMetadataStore.getInstance().addMetadataFor("some-plugin", new PackageConfigurations());
  Configuration configuration = new Configuration(create("kEY1", false, "vALue1"), create("KEY_MORE_2", false, "VALUE_2"), create("key_3", false, "value3"));
  PackageRepository repository = PackageRepositoryMother.create("repo1", "repo1-name", "some-plugin", "1", configuration);
  assertThat(repository.getConfigForDisplay(), is("Repository: [key1=vALue1, key_more_2=VALUE_2, key_3=value3]"));
}

  public static void clear() {
    List<String> plugins = RepositoryMetadataStore.getInstance().getPlugins();
    for (String pluginId : plugins) {
      RepositoryMetadataStore.getInstance().removeMetadata(pluginId);
      PackageMetadataStore.getInstance().removeMetadata(pluginId);
    }
  }
}