use of org.apache.archiva.metadata.repository.cassandra.model.Repository in project archiva by apache.
the class RepositoriesNamespaceTest method testMetadataRepo.
@Test
public void testMetadataRepo() throws Exception {
Repository r = null;
Namespace n = null;
try {
cmr.updateNamespace("release", "org");
r = cmr.getRepository("release");
assertThat(r).isNotNull();
assertThat(cmr.getRepositories()).isNotEmpty().hasSize(1);
assertThat(cmr.getNamespaces("release")).isNotEmpty().hasSize(1);
n = cmr.getNamespace("release", "org");
assertThat(n).isNotNull();
assertThat(n.getRepository()).isNotNull();
cmr.updateNamespace("release", "org.apache");
r = cmr.getRepository("release");
assertThat(r).isNotNull();
assertThat(cmr.getNamespaces("release")).isNotEmpty().hasSize(2);
cmr.removeNamespace("release", "org.apache");
assertThat(cmr.getNamespaces("release")).isNotEmpty().hasSize(1);
assertThat(cmr.getNamespaces("release")).containsExactly("org");
ProjectMetadata projectMetadata = new ProjectMetadata();
projectMetadata.setId("theproject");
projectMetadata.setNamespace("org");
cmr.updateProject("release", projectMetadata);
assertThat(cmr.getProjects("release", "org")).isNotEmpty().hasSize(1).containsExactly("theproject");
cmr.removeProject("release", "org", "theproject");
assertThat(cmr.getProjects("release", "org")).isEmpty();
cmr.removeRepository("release");
r = cmr.getRepository("release");
assertThat(r).isNull();
} catch (Exception e) {
logger.error(e.getMessage(), e);
throw e;
} finally {
CassandraMetadataRepositoryTest.clearReposAndNamespace(cassandraArchivaManager);
}
}
use of org.apache.archiva.metadata.repository.cassandra.model.Repository in project archiva by apache.
the class CassandraMetadataRepository method mapProjectVersionMetadataModel.
protected ProjectVersionMetadataModel mapProjectVersionMetadataModel(ColumnSlice<String, String> columnSlice) {
ProjectVersionMetadataModel projectVersionMetadataModel = new ProjectVersionMetadataModel();
projectVersionMetadataModel.setId(getStringValue(columnSlice, ID.toString()));
projectVersionMetadataModel.setDescription(getStringValue(columnSlice, DESCRIPTION.toString()));
projectVersionMetadataModel.setName(getStringValue(columnSlice, NAME.toString()));
Namespace namespace = new //
Namespace(//
getStringValue(columnSlice, NAMESPACE_ID.toString()), new Repository(getStringValue(columnSlice, REPOSITORY_NAME.toString())));
projectVersionMetadataModel.setNamespace(namespace);
projectVersionMetadataModel.setIncomplete(Boolean.parseBoolean(getStringValue(columnSlice, "incomplete")));
projectVersionMetadataModel.setProjectId(getStringValue(columnSlice, PROJECT_ID.toString()));
projectVersionMetadataModel.setUrl(getStringValue(columnSlice, URL.toString()));
return projectVersionMetadataModel;
}
use of org.apache.archiva.metadata.repository.cassandra.model.Repository in project archiva by apache.
the class CassandraMetadataRepository method getOrCreateRepository.
/**
* if the repository doesn't exist it will be created
*
* @param repositoryId
* @return
*/
public Repository getOrCreateRepository(String repositoryId) throws MetadataRepositoryException {
String cf = cassandraArchivaManager.getRepositoryFamilyName();
QueryResult<OrderedRows<String, String, String>> result = //
HFactory.createRangeSlicesQuery(keyspace, StringSerializer.get(), StringSerializer.get(), //
StringSerializer.get()).setColumnFamily(//
cf).setColumnNames(//
REPOSITORY_NAME.toString()).addEqualsExpression(REPOSITORY_NAME.toString(), //
repositoryId).execute();
if (result.get().getCount() < 1) {
// we need to create the repository
Repository repository = new Repository(repositoryId);
try {
MutationResult mutationResult = //
HFactory.createMutator(keyspace, StringSerializer.get()).addInsertion(repositoryId, cf, //
CassandraUtils.column(REPOSITORY_NAME.toString(), repository.getName())).execute();
logger.debug("time to insert repository: {}", mutationResult.getExecutionTimeMicro());
return repository;
} catch (HInvalidRequestException e) {
logger.error(e.getMessage(), e);
throw new MetadataRepositoryException(e.getMessage(), e);
}
}
return new Repository(result.get().getList().get(0).getColumnSlice().getColumnByName(REPOSITORY_NAME.toString()).getValue());
}
use of org.apache.archiva.metadata.repository.cassandra.model.Repository in project archiva by apache.
the class CassandraMetadataRepository method updateOrAddNamespace.
private Namespace updateOrAddNamespace(String repositoryId, String namespaceId) throws MetadataRepositoryException {
try {
Repository repository = getOrCreateRepository(repositoryId);
String key = new Namespace.KeyBuilder().withNamespace(namespaceId).withRepositoryId(repositoryId).build();
Namespace namespace = getNamespace(repositoryId, namespaceId);
if (namespace == null) {
String cf = cassandraArchivaManager.getNamespaceFamilyName();
namespace = new Namespace(namespaceId, repository);
HFactory.createMutator(keyspace, StringSerializer.get()).addInsertion(key, cf, //
CassandraUtils.column(NAME.toString(), namespace.getName())).addInsertion(key, cf, //
CassandraUtils.column(REPOSITORY_NAME.toString(), repository.getName())).execute();
}
return namespace;
} catch (HInvalidRequestException e) {
logger.error(e.getMessage(), e);
throw new MetadataRepositoryException(e.getMessage(), e);
}
}
use of org.apache.archiva.metadata.repository.cassandra.model.Repository in project archiva by apache.
the class CassandraMetadataRepository method updateProjectVersion.
@Override
public void updateProjectVersion(String repositoryId, String namespaceId, String projectId, ProjectVersionMetadata versionMetadata) throws MetadataRepositoryException {
try {
Namespace namespace = getNamespace(repositoryId, namespaceId);
if (namespace == null) {
updateOrAddNamespace(repositoryId, namespaceId);
}
if (getProject(repositoryId, namespaceId, projectId) == null) {
ProjectMetadata projectMetadata = new ProjectMetadata();
projectMetadata.setNamespace(namespaceId);
projectMetadata.setId(projectId);
updateProject(repositoryId, projectMetadata);
}
} catch (MetadataResolutionException e) {
throw new MetadataRepositoryException(e.getMessage(), e);
}
QueryResult<OrderedRows<String, String, String>> result = //
HFactory.createRangeSlicesQuery(keyspace, ss, ss, //
ss).setColumnFamily(//
cassandraArchivaManager.getProjectVersionMetadataFamilyName()).setColumnNames(//
PROJECT_VERSION.toString()).addEqualsExpression(REPOSITORY_NAME.toString(), //
repositoryId).addEqualsExpression(NAMESPACE_ID.toString(), //
namespaceId).addEqualsExpression(PROJECT_ID.toString(), //
projectId).addEqualsExpression(PROJECT_VERSION.toString(), //
versionMetadata.getId()).execute();
ProjectVersionMetadataModel projectVersionMetadataModel = null;
boolean creation = true;
if (result.get().getCount() > 0) {
projectVersionMetadataModel = mapProjectVersionMetadataModel(result.get().getList().get(0).getColumnSlice());
creation = false;
} else {
projectVersionMetadataModel = getModelMapper().map(versionMetadata, ProjectVersionMetadataModel.class);
}
projectVersionMetadataModel.setProjectId(projectId);
projectVersionMetadataModel.setNamespace(new Namespace(namespaceId, new Repository(repositoryId)));
projectVersionMetadataModel.setCiManagement(versionMetadata.getCiManagement());
projectVersionMetadataModel.setIssueManagement(versionMetadata.getIssueManagement());
projectVersionMetadataModel.setOrganization(versionMetadata.getOrganization());
projectVersionMetadataModel.setScm(versionMetadata.getScm());
projectVersionMetadataModel.setMailingLists(versionMetadata.getMailingLists());
projectVersionMetadataModel.setDependencies(versionMetadata.getDependencies());
projectVersionMetadataModel.setLicenses(versionMetadata.getLicenses());
// we don't test of repository and namespace really exist !
String key = //
new ProjectVersionMetadataModel.KeyBuilder().withRepository(//
repositoryId).withNamespace(//
namespaceId).withProjectId(//
projectId).withProjectVersion(//
versionMetadata.getVersion()).withId(//
versionMetadata.getId()).build();
// FIXME nested objects to store!!!
if (creation) {
String cf = cassandraArchivaManager.getProjectVersionMetadataFamilyName();
Mutator<String> mutator = projectVersionMetadataTemplate.createMutator().addInsertion(key, cf, //
column(PROJECT_ID.toString(), projectId)).addInsertion(key, cf, //
column(REPOSITORY_NAME.toString(), repositoryId)).addInsertion(key, cf, //
column(NAMESPACE_ID.toString(), namespaceId)).addInsertion(key, cf, //
column(PROJECT_VERSION.toString(), versionMetadata.getVersion()));
addInsertion(mutator, key, cf, DESCRIPTION.toString(), versionMetadata.getDescription());
addInsertion(mutator, key, cf, NAME.toString(), versionMetadata.getName());
addInsertion(mutator, key, cf, "incomplete", Boolean.toString(versionMetadata.isIncomplete()));
addInsertion(mutator, key, cf, URL.toString(), versionMetadata.getUrl());
{
CiManagement ci = versionMetadata.getCiManagement();
if (ci != null) {
addInsertion(mutator, key, cf, "ciManagement.system", ci.getSystem());
addInsertion(mutator, key, cf, "ciManagement.url", ci.getUrl());
}
}
{
IssueManagement issueManagement = versionMetadata.getIssueManagement();
if (issueManagement != null) {
addInsertion(mutator, key, cf, "issueManagement.system", issueManagement.getSystem());
addInsertion(mutator, key, cf, "issueManagement.url", issueManagement.getUrl());
}
}
{
Organization organization = versionMetadata.getOrganization();
if (organization != null) {
addInsertion(mutator, key, cf, "organization.name", organization.getName());
addInsertion(mutator, key, cf, "organization.url", organization.getUrl());
}
}
{
Scm scm = versionMetadata.getScm();
if (scm != null) {
addInsertion(mutator, key, cf, "scm.url", scm.getUrl());
addInsertion(mutator, key, cf, "scm.connection", scm.getConnection());
addInsertion(mutator, key, cf, "scm.developerConnection", scm.getDeveloperConnection());
}
}
recordMailingList(key, versionMetadata.getMailingLists());
recordLicenses(key, versionMetadata.getLicenses());
recordDependencies(key, versionMetadata.getDependencies(), repositoryId);
MutationResult mutationResult = mutator.execute();
} else {
ColumnFamilyUpdater<String, String> updater = projectVersionMetadataTemplate.createUpdater(key);
addUpdateStringValue(updater, PROJECT_ID.toString(), projectId);
addUpdateStringValue(updater, REPOSITORY_NAME.toString(), repositoryId);
addUpdateStringValue(updater, NAMESPACE_ID.toString(), namespaceId);
addUpdateStringValue(updater, PROJECT_VERSION.toString(), versionMetadata.getVersion());
addUpdateStringValue(updater, DESCRIPTION.toString(), versionMetadata.getDescription());
addUpdateStringValue(updater, NAME.toString(), versionMetadata.getName());
updater.setString("incomplete", Boolean.toString(versionMetadata.isIncomplete()));
addUpdateStringValue(updater, URL.toString(), versionMetadata.getUrl());
{
CiManagement ci = versionMetadata.getCiManagement();
if (ci != null) {
addUpdateStringValue(updater, "ciManagement.system", ci.getSystem());
addUpdateStringValue(updater, "ciManagement.url", ci.getUrl());
}
}
{
IssueManagement issueManagement = versionMetadata.getIssueManagement();
if (issueManagement != null) {
addUpdateStringValue(updater, "issueManagement.system", issueManagement.getSystem());
addUpdateStringValue(updater, "issueManagement.url", issueManagement.getUrl());
}
}
{
Organization organization = versionMetadata.getOrganization();
if (organization != null) {
addUpdateStringValue(updater, "organization.name", organization.getName());
addUpdateStringValue(updater, "organization.url", organization.getUrl());
}
}
{
Scm scm = versionMetadata.getScm();
if (scm != null) {
addUpdateStringValue(updater, "scm.url", scm.getUrl());
addUpdateStringValue(updater, "scm.connection", scm.getConnection());
addUpdateStringValue(updater, "scm.developerConnection", scm.getDeveloperConnection());
}
}
// update is a delete record
removeMailingList(key);
recordMailingList(key, versionMetadata.getMailingLists());
removeLicenses(key);
recordLicenses(key, versionMetadata.getLicenses());
removeDependencies(key);
recordDependencies(key, versionMetadata.getDependencies(), repositoryId);
projectVersionMetadataTemplate.update(updater);
}
ArtifactMetadataModel artifactMetadataModel = new ArtifactMetadataModel();
artifactMetadataModel.setRepositoryId(repositoryId);
artifactMetadataModel.setNamespace(namespaceId);
artifactMetadataModel.setProject(projectId);
artifactMetadataModel.setProjectVersion(versionMetadata.getVersion());
artifactMetadataModel.setVersion(versionMetadata.getVersion());
updateFacets(versionMetadata, artifactMetadataModel);
}
Aggregations