source.dussan.org Git - archiva.git/blob

   1 package org.apache.archiva.metadata.repository.cassandra;
   2
   3 /*
   4  * Licensed to the Apache Software Foundation (ASF) under one
   5  * or more contributor license agreements.  See the NOTICE file
   6  * distributed with this work for additional information
   7  * regarding copyright ownership.  The ASF licenses this file
   8  * to you under the Apache License, Version 2.0 (the
   9  * "License"); you may not use this file except in compliance
  10  * with the License.  You may obtain a copy of the License at
  11  *
  12  *  http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17  * KIND, either express or implied.  See the License for the
  18  * specific language governing permissions and limitations
  19  * under the License.
  20  */
  21
  22 import com.google.common.base.Function;
  23 import com.google.common.base.Predicate;
  24 import com.google.common.collect.Iterables;
  25 import com.netflix.astyanax.Keyspace;
  26 import com.netflix.astyanax.connectionpool.exceptions.ConnectionException;
  27 import com.netflix.astyanax.connectionpool.exceptions.NotFoundException;
  28 import com.netflix.astyanax.entitystore.DefaultEntityManager;
  29 import com.netflix.astyanax.entitystore.EntityManager;
  30 import net.sf.beanlib.provider.replicator.BeanReplicator;
  31 import org.apache.archiva.configuration.ArchivaConfiguration;
  32 import org.apache.archiva.metadata.model.ArtifactMetadata;
  33 import org.apache.archiva.metadata.model.FacetedMetadata;
  34 import org.apache.archiva.metadata.model.MetadataFacet;
  35 import org.apache.archiva.metadata.model.MetadataFacetFactory;
  36 import org.apache.archiva.metadata.model.ProjectMetadata;
  37 import org.apache.archiva.metadata.model.ProjectVersionMetadata;
  38 import org.apache.archiva.metadata.model.ProjectVersionReference;
  39 import org.apache.archiva.metadata.repository.MetadataRepository;
  40 import org.apache.archiva.metadata.repository.MetadataRepositoryException;
  41 import org.apache.archiva.metadata.repository.MetadataResolutionException;
  42 import org.apache.archiva.metadata.repository.cassandra.model.ArtifactMetadataModel;
  43 import org.apache.archiva.metadata.repository.cassandra.model.MetadataFacetModel;
  44 import org.apache.archiva.metadata.repository.cassandra.model.Namespace;
  45 import org.apache.archiva.metadata.repository.cassandra.model.Project;
  46 import org.apache.archiva.metadata.repository.cassandra.model.ProjectVersionMetadataModel;
  47 import org.apache.archiva.metadata.repository.cassandra.model.Repository;
  48 import org.apache.commons.lang.StringUtils;
  49 import org.slf4j.Logger;
  50 import org.slf4j.LoggerFactory;
  51
  52 import javax.persistence.PersistenceException;
  53 import java.util.ArrayList;
  54 import java.util.Collection;
  55 import java.util.Collections;
  56 import java.util.Date;
  57 import java.util.HashMap;
  58 import java.util.HashSet;
  59 import java.util.Iterator;
  60 import java.util.List;
  61 import java.util.Map;
  62 import java.util.Properties;
  63 import java.util.Set;
  64
  65 /**
  66  * @author Olivier Lamy
  67  */
  68 public class CassandraMetadataRepository
  69     implements MetadataRepository
  70 {
  71
  72     private Logger logger = LoggerFactory.getLogger( getClass() );
  73
  74     private ArchivaConfiguration configuration;
  75
  76     private final Map<String, MetadataFacetFactory> metadataFacetFactories;
  77
  78     private CassandraEntityManagerFactory cassandraEntityManagerFactory;
  79
  80     public CassandraMetadataRepository( Map<String, MetadataFacetFactory> metadataFacetFactories,
  81                                         ArchivaConfiguration configuration, CassandraEntityManagerFactory cassandraEntityManagerFactory )
  82     {
  83         this.metadataFacetFactories = metadataFacetFactories;
  84         this.configuration = configuration;
  85         this.cassandraEntityManagerFactory = cassandraEntityManagerFactory;
  86     }
  87
  88
  89
  90     public EntityManager<Repository, String> getRepositoryEntityManager()
  91     {
  92         return this.cassandraEntityManagerFactory.getRepositoryEntityManager();
  93     }
  94
  95     public EntityManager<Namespace, String> getNamespaceEntityManager()
  96     {
  97         return this.cassandraEntityManagerFactory.getNamespaceEntityManager();
  98     }
  99
 100     public EntityManager<Project, String> getProjectEntityManager()
 101     {
 102         return this.cassandraEntityManagerFactory.getProjectEntityManager();
 103     }
 104
 105     public EntityManager<ArtifactMetadataModel, String> getArtifactMetadataModelEntityManager()
 106     {
 107         return cassandraEntityManagerFactory.getArtifactMetadataModelEntityManager();
 108     }
 109
 110     public EntityManager<MetadataFacetModel, String> getMetadataFacetModelEntityManager()
 111     {
 112         return this.cassandraEntityManagerFactory.getMetadataFacetModelEntityManager();
 113     }
 114
 115     public EntityManager<ProjectVersionMetadataModel, String> getProjectVersionMetadataModelEntityManager()
 116     {
 117         return this.cassandraEntityManagerFactory.getProjectVersionMetadataModelEntityManager();
 118     }
 119
 120     @Override
 121     public void updateNamespace( String repositoryId, String namespaceId )
 122         throws MetadataRepositoryException
 123     {
 124         updateOrAddNamespace( repositoryId, namespaceId );
 125
 126     }
 127
 128     public Namespace updateOrAddNamespace( String repositoryId, String namespaceId )
 129         throws MetadataRepositoryException
 130     {
 131         try
 132         {
 133             Repository repository = this.getRepositoryEntityManager().get( repositoryId );
 134
 135             if ( repository == null )
 136             {
 137                 repository = new Repository( repositoryId );
 138
 139                 Namespace namespace = new Namespace( namespaceId, repository );
 140                 this.getRepositoryEntityManager().put( repository );
 141
 142                 this.getNamespaceEntityManager().put( namespace );
 143             }
 144             // FIXME add a Namespace id builder
 145             Namespace namespace = getNamespaceEntityManager().get(
 146                 new Namespace.KeyBuilder().withNamespace( namespaceId ).withRepositoryId( repositoryId ).build() );
 147             if ( namespace == null )
 148             {
 149                 namespace = new Namespace( namespaceId, repository );
 150                 getNamespaceEntityManager().put( namespace );
 151             }
 152             return namespace;
 153         }
 154         catch ( PersistenceException e )
 155         {
 156             throw new MetadataRepositoryException( e.getMessage(), e );
 157         }
 158
 159     }
 160
 161
 162     @Override
 163     public void removeNamespace( String repositoryId, String namespaceId )
 164         throws MetadataRepositoryException
 165     {
 166         try
 167         {
 168             Namespace namespace = getNamespaceEntityManager().get(
 169                 new Namespace.KeyBuilder().withNamespace( namespaceId ).withRepositoryId( repositoryId ).build() );
 170             if ( namespace != null )
 171             {
 172                 getNamespaceEntityManager().remove( namespace );
 173             }
 174         }
 175         catch ( PersistenceException e )
 176         {
 177             throw new MetadataRepositoryException( e.getMessage(), e );
 178         }
 179     }
 180
 181
 182     @Override
 183     public void removeRepository( final String repositoryId )
 184         throws MetadataRepositoryException
 185     {
 186         try
 187         {
 188             final List<ArtifactMetadataModel> artifactMetadataModels = new ArrayList<ArtifactMetadataModel>();
 189
 190             // remove data related to the repository
 191             this.getArtifactMetadataModelEntityManager().visitAll( new Function<ArtifactMetadataModel, Boolean>()
 192             {
 193                 @Override
 194                 public Boolean apply( ArtifactMetadataModel artifactMetadataModel )
 195                 {
 196                     if ( artifactMetadataModel != null )
 197                     {
 198                         if ( StringUtils.equals( artifactMetadataModel.getRepositoryId(), repositoryId ) )
 199                         {
 200                             artifactMetadataModels.add( artifactMetadataModel );
 201                         }
 202                     }
 203                     return Boolean.TRUE;
 204                 }
 205             } );
 206
 207             getArtifactMetadataModelEntityManager().remove( artifactMetadataModels );
 208
 209             final List<Namespace> namespaces = new ArrayList<Namespace>();
 210
 211             getNamespaceEntityManager().visitAll( new Function<Namespace, Boolean>()
 212             {
 213                 @Override
 214                 public Boolean apply( Namespace namespace )
 215                 {
 216                     if ( namespace != null )
 217                     {
 218                         if ( StringUtils.equals( namespace.getRepository().getId(), repositoryId ) )
 219                         {
 220                             namespaces.add( namespace );
 221                         }
 222                     }
 223                     return Boolean.TRUE;
 224                 }
 225             } );
 226
 227             getNamespaceEntityManager().remove( namespaces );
 228
 229             final List<Project> projects = new ArrayList<Project>();
 230             getProjectEntityManager().visitAll( new Function<Project, Boolean>()
 231             {
 232                 @Override
 233                 public Boolean apply( Project project )
 234                 {
 235                     if ( project != null )
 236                     {
 237                         if ( StringUtils.equals( project.getNamespace().getRepository().getId(), repositoryId ) )
 238                         {
 239                             projects.add( project );
 240                         }
 241                     }
 242                     return Boolean.TRUE;
 243                 }
 244             } );
 245
 246             getProjectEntityManager().remove( projects );
 247
 248             // TODO  cleanup or not
 249             //final List<MetadataFacetModel> metadataFacetModels = new ArrayList<MetadataFacetModel>(  );
 250             //getMetadataFacetModelEntityManager().visitAll( new Function<MetadataFacetModel, Boolean>()
 251
 252             final List<ProjectVersionMetadataModel> projectVersionMetadataModels =
 253                 new ArrayList<ProjectVersionMetadataModel>();
 254
 255             getProjectVersionMetadataModelEntityManager().visitAll( new Function<ProjectVersionMetadataModel, Boolean>()
 256             {
 257                 @Override
 258                 public Boolean apply( ProjectVersionMetadataModel projectVersionMetadataModel )
 259                 {
 260                     if ( projectVersionMetadataModel != null )
 261                     {
 262                         if ( StringUtils.equals( projectVersionMetadataModel.getNamespace().getRepository().getId(),
 263                                                  repositoryId ) )
 264                         {
 265                             projectVersionMetadataModels.add( projectVersionMetadataModel );
 266                         }
 267                     }
 268                     return Boolean.TRUE;
 269                 }
 270             } );
 271
 272             getProjectVersionMetadataModelEntityManager().remove( projectVersionMetadataModels );
 273
 274             Repository repository = getRepositoryEntityManager().get( repositoryId );
 275             if ( repository != null )
 276             {
 277                 getRepositoryEntityManager().remove( repository );
 278             }
 279
 280         }
 281         catch ( PersistenceException e )
 282         {
 283             throw new MetadataRepositoryException( e.getMessage(), e );
 284         }
 285     }
 286
 287     @Override
 288     public Collection<String> getRepositories()
 289         throws MetadataRepositoryException
 290     {
 291         try
 292         {
 293             logger.debug( "getRepositories" );
 294
 295             List<Repository> repositories = getRepositoryEntityManager().getAll();
 296             if ( repositories == null )
 297             {
 298                 return Collections.emptyList();
 299             }
 300             List<String> repoIds = new ArrayList<String>( repositories.size() );
 301             for ( Repository repository : repositories )
 302             {
 303                 repoIds.add( repository.getName() );
 304             }
 305             logger.debug( "getRepositories found: {}", repoIds );
 306             return repoIds;
 307         }
 308         catch ( PersistenceException e )
 309         {
 310             throw new MetadataRepositoryException( e.getMessage(), e );
 311         }
 312
 313     }
 314
 315
 316     @Override
 317     public Collection<String> getRootNamespaces( final String repoId )
 318         throws MetadataResolutionException
 319     {
 320         try
 321         {
 322             final Set<String> namespaces = new HashSet<String>();
 323
 324             getNamespaceEntityManager().visitAll( new Function<Namespace, Boolean>()
 325             {
 326                 // @Nullable add dependency ?
 327                 @Override
 328                 public Boolean apply( Namespace namespace )
 329                 {
 330                     if ( namespace != null && namespace.getRepository() != null && StringUtils.equalsIgnoreCase( repoId,
 331                                                                                                                  namespace.getRepository().getId() ) )
 332                     {
 333                         String name = namespace.getName();
 334                         if ( StringUtils.isNotEmpty( name ) )
 335                         {
 336                             namespaces.add( StringUtils.substringBefore( name, "." ) );
 337                         }
 338                     }
 339                     return Boolean.TRUE;
 340                 }
 341             } );
 342
 343             return namespaces;
 344         }
 345         catch ( PersistenceException e )
 346         {
 347             throw new MetadataResolutionException( e.getMessage(), e );
 348         }
 349     }
 350
 351     @Override
 352     public Collection<String> getNamespaces( final String repoId, final String namespaceId )
 353         throws MetadataResolutionException
 354     {
 355         try
 356         {
 357             final Set<String> namespaces = new HashSet<String>();
 358
 359             getNamespaceEntityManager().visitAll( new Function<Namespace, Boolean>()
 360             {
 361                 // @Nullable add dependency ?
 362                 @Override
 363                 public Boolean apply( Namespace namespace )
 364                 {
 365                     if ( namespace != null && namespace.getRepository() != null && StringUtils.equalsIgnoreCase( repoId,
 366                                                                                                                  namespace.getRepository().getId() ) )
 367                     {
 368                         String currentNamespace = namespace.getName();
 369                         // we only return childs
 370                         if ( StringUtils.startsWith( currentNamespace, namespaceId ) && (
 371                             StringUtils.length( currentNamespace ) > StringUtils.length( namespaceId ) ) )
 372                         {
 373                             // store after namespaceId '.' but before next '.'
 374                             // call org namespace org.apache.maven.shared -> stored apache
 375
 376                             String calledNamespace =
 377                                 StringUtils.endsWith( namespaceId, "." ) ? namespaceId : namespaceId + ".";
 378                             String storedNamespace = StringUtils.substringAfter( currentNamespace, calledNamespace );
 379
 380                             storedNamespace = StringUtils.substringBefore( storedNamespace, "." );
 381
 382                             namespaces.add( storedNamespace );
 383                         }
 384                     }
 385                     return Boolean.TRUE;
 386                 }
 387             } );
 388
 389             return namespaces;
 390         }
 391         catch ( PersistenceException e )
 392         {
 393             throw new MetadataResolutionException( e.getMessage(), e );
 394         }
 395
 396     }
 397
 398     public List<String> getNamespaces( final String repoId )
 399         throws MetadataResolutionException
 400     {
 401         try
 402         {
 403             logger.debug( "getNamespaces for repository '{}'", repoId );
 404             //TypedQuery<Repository> typedQuery =
 405             //    entityManager.createQuery( "select n from Namespace n where n.repository_id=:id", Namespace.class );
 406
 407             //List<Repository> namespaces = typedQuery.setParameter( "id", repoId ).getResultList();
 408
 409             Repository repository = getRepositoryEntityManager().get( repoId );
 410
 411             if ( repository == null )
 412             {
 413                 return Collections.emptyList();
 414             }
 415
 416             // FIXME find correct cql query
 417             //String query = "select * from namespace where repository.id = '" + repoId + "';";
 418
 419             //List<Namespace> namespaces = getNamespaceEntityManager().find( query );
 420
 421             final Set<Namespace> namespaces = new HashSet<Namespace>();
 422
 423             getNamespaceEntityManager().visitAll( new Function<Namespace, Boolean>()
 424             {
 425                 // @Nullable add dependency ?
 426                 @Override
 427                 public Boolean apply( Namespace namespace )
 428                 {
 429                     if ( namespace != null && namespace.getRepository() != null && StringUtils.equalsIgnoreCase( repoId,
 430                                                                                                                  namespace.getRepository().getId() ) )
 431                     {
 432                         namespaces.add( namespace );
 433                     }
 434                     return Boolean.TRUE;
 435                 }
 436             } );
 437
 438             repository.setNamespaces( new ArrayList<Namespace>( namespaces ) );
 439
 440             if ( repository == null || repository.getNamespaces().isEmpty() )
 441             {
 442                 return Collections.emptyList();
 443             }
 444             List<String> namespaceIds = new ArrayList<String>( repository.getNamespaces().size() );
 445
 446             for ( Namespace n : repository.getNamespaces() )
 447             {
 448                 namespaceIds.add( n.getName() );
 449             }
 450
 451             logger.debug( "getNamespaces for repository '{}' found {}", repoId, namespaceIds.size() );
 452             return namespaceIds;
 453         }
 454         catch ( PersistenceException e )
 455         {
 456             throw new MetadataResolutionException( e.getMessage(), e );
 457         }
 458     }
 459
 460
 461     @Override
 462     public void updateProject( String repositoryId, ProjectMetadata projectMetadata )
 463         throws MetadataRepositoryException
 464     {
 465
 466         // project exists ? if yes return
 467         String projectKey = new Project.KeyBuilder().withProjectId( projectMetadata.getId() ).withNamespace(
 468             new Namespace( projectMetadata.getNamespace(), new Repository( repositoryId ) ) ).build();
 469
 470         Project project = getProjectEntityManager().get( projectKey );
 471         if ( project != null )
 472         {
 473             return;
 474         }
 475
 476         String namespaceKey = new Namespace.KeyBuilder().withRepositoryId( repositoryId ).withNamespace(
 477             projectMetadata.getNamespace() ).build();
 478         Namespace namespace = getNamespaceEntityManager().get( namespaceKey );
 479         if ( namespace == null )
 480         {
 481             namespace = updateOrAddNamespace( repositoryId, projectMetadata.getNamespace() );
 482         }
 483
 484         project = new Project( projectKey, projectMetadata.getId(), namespace );
 485
 486         try
 487         {
 488             getProjectEntityManager().put( project );
 489         }
 490         catch ( PersistenceException e )
 491         {
 492             throw new MetadataRepositoryException( e.getMessage(), e );
 493         }
 494
 495     }
 496
 497     @Override
 498     public void removeProject( final String repositoryId, final String namespaceId, final String projectId )
 499         throws MetadataRepositoryException
 500     {
 501
 502         // cleanup ArtifactMetadataModel
 503         final List<ArtifactMetadataModel> artifactMetadataModels = new ArrayList<ArtifactMetadataModel>();
 504
 505         getArtifactMetadataModelEntityManager().visitAll( new Function<ArtifactMetadataModel, Boolean>()
 506         {
 507             @Override
 508             public Boolean apply( ArtifactMetadataModel artifactMetadataModel )
 509             {
 510                 if ( artifactMetadataModel != null )
 511                 {
 512                     if ( StringUtils.equals( artifactMetadataModel.getRepositoryId(), repositoryId )
 513                         && StringUtils.equals( artifactMetadataModel.getNamespace(), namespaceId )
 514                         && StringUtils.equals( artifactMetadataModel.getProject(), projectId ) )
 515                     {
 516                         artifactMetadataModels.add( artifactMetadataModel );
 517                     }
 518                 }
 519                 return Boolean.TRUE;
 520             }
 521         } );
 522
 523         getArtifactMetadataModelEntityManager().remove( artifactMetadataModels );
 524
 525         Namespace namespace = new Namespace( namespaceId, new Repository( repositoryId ) );
 526
 527         final List<ProjectVersionMetadataModel> projectVersionMetadataModels =
 528             new ArrayList<ProjectVersionMetadataModel>();
 529
 530         getProjectVersionMetadataModelEntityManager().visitAll( new Function<ProjectVersionMetadataModel, Boolean>()
 531         {
 532             @Override
 533             public Boolean apply( ProjectVersionMetadataModel projectVersionMetadataModel )
 534             {
 535                 if ( projectVersionMetadataModel != null )
 536                 {
 537                     if ( StringUtils.equals( repositoryId,
 538                                              projectVersionMetadataModel.getNamespace().getRepository().getName() )
 539                         && StringUtils.equals( namespaceId, projectVersionMetadataModel.getNamespace().getName() )
 540                         && StringUtils.equals( projectId, projectVersionMetadataModel.getProjectId() ) )
 541                     {
 542                         projectVersionMetadataModels.add( projectVersionMetadataModel );
 543                     }
 544                 }
 545                 return Boolean.TRUE;
 546             }
 547         } );
 548
 549         if ( !projectVersionMetadataModels.isEmpty() )
 550         {
 551             getProjectVersionMetadataModelEntityManager().remove( projectVersionMetadataModels );
 552         }
 553
 554         String key = new Project.KeyBuilder().withNamespace( namespace ).withProjectId( projectId ).build();
 555
 556         Project project = getProjectEntityManager().get( key );
 557         if ( project == null )
 558         {
 559             logger.debug( "removeProject notfound" );
 560             return;
 561         }
 562         logger.debug( "removeProject {}", project );
 563
 564         getProjectEntityManager().remove( project );
 565     }
 566
 567     @Override
 568     public Collection<String> getProjectVersions( final String repoId, final String namespace, final String projectId )
 569         throws MetadataResolutionException
 570     {
 571         final Set<String> versions = new HashSet<String>();
 572         getProjectVersionMetadataModelEntityManager().visitAll( new Function<ProjectVersionMetadataModel, Boolean>()
 573         {
 574             @Override
 575             public Boolean apply( ProjectVersionMetadataModel projectVersionMetadataModel )
 576             {
 577                 if ( projectVersionMetadataModel != null )
 578                 {
 579                     if ( StringUtils.equals( repoId,
 580                                              projectVersionMetadataModel.getNamespace().getRepository().getName() )
 581                         && StringUtils.startsWith( projectVersionMetadataModel.getNamespace().getName(), namespace )
 582                         && StringUtils.equals( projectId, projectVersionMetadataModel.getProjectId() ) )
 583                     {
 584                         versions.add( projectVersionMetadataModel.getId() );
 585                     }
 586                 }
 587                 return Boolean.TRUE;
 588             }
 589         } );
 590         // FIXME use cql query
 591         getArtifactMetadataModelEntityManager().visitAll( new Function<ArtifactMetadataModel, Boolean>()
 592         {
 593             @Override
 594             public Boolean apply( ArtifactMetadataModel artifactMetadataModel )
 595             {
 596                 if ( artifactMetadataModel != null )
 597                 {
 598                     if ( StringUtils.equals( repoId, artifactMetadataModel.getRepositoryId() ) && StringUtils.equals(
 599                         namespace, artifactMetadataModel.getNamespace() ) && StringUtils.equals( projectId,
 600                                                                                                  artifactMetadataModel.getProject() ) )
 601                     {
 602                         versions.add( artifactMetadataModel.getProjectVersion() );
 603                     }
 604                 }
 605                 return Boolean.TRUE;
 606             }
 607         } );
 608
 609         return versions;
 610     }
 611
 612     @Override
 613     public void updateArtifact( String repositoryId, String namespaceId, String projectId, String projectVersion,
 614                                 ArtifactMetadata artifactMeta )
 615         throws MetadataRepositoryException
 616     {
 617         String namespaceKey =
 618             new Namespace.KeyBuilder().withRepositoryId( repositoryId ).withNamespace( namespaceId ).build();
 619         // create the namespace if not exists
 620         Namespace namespace = getNamespaceEntityManager().get( namespaceKey );
 621         if ( namespace == null )
 622         {
 623             namespace = updateOrAddNamespace( repositoryId, namespaceId );
 624         }
 625
 626         // create the project if not exist
 627         String projectKey = new Project.KeyBuilder().withNamespace( namespace ).withProjectId( projectId ).build();
 628
 629         Project project = getProjectEntityManager().get( projectKey );
 630         if ( project == null )
 631         {
 632             project = new Project( projectKey, projectId, namespace );
 633             try
 634             {
 635                 getProjectEntityManager().put( project );
 636             }
 637             catch ( PersistenceException e )
 638             {
 639                 throw new MetadataRepositoryException( e.getMessage(), e );
 640             }
 641         }
 642
 643         String key = new ArtifactMetadataModel.KeyBuilder().withNamespace( namespace ).withProject( projectId ).withId(
 644             artifactMeta.getId() ).withProjectVersion( projectVersion ).build();
 645
 646         ArtifactMetadataModel artifactMetadataModel = getArtifactMetadataModelEntityManager().get( key );
 647         if ( artifactMetadataModel == null )
 648         {
 649             artifactMetadataModel = new ArtifactMetadataModel( key, artifactMeta.getId(), repositoryId, namespaceId,
 650                                                                artifactMeta.getProject(), projectVersion,
 651                                                                artifactMeta.getVersion(),
 652                                                                artifactMeta.getFileLastModified(),
 653                                                                artifactMeta.getSize(), artifactMeta.getMd5(),
 654                                                                artifactMeta.getSha1(), artifactMeta.getWhenGathered() );
 655
 656         }
 657         else
 658         {
 659             artifactMetadataModel.setFileLastModified( artifactMeta.getFileLastModified().getTime() );
 660             artifactMetadataModel.setWhenGathered( artifactMeta.getWhenGathered().getTime() );
 661             artifactMetadataModel.setSize( artifactMeta.getSize() );
 662             artifactMetadataModel.setMd5( artifactMeta.getMd5() );
 663             artifactMetadataModel.setSha1( artifactMeta.getSha1() );
 664             artifactMetadataModel.setVersion( artifactMeta.getVersion() );
 665         }
 666
 667         try
 668         {
 669             getArtifactMetadataModelEntityManager().put( artifactMetadataModel );
 670         }
 671         catch ( PersistenceException e )
 672         {
 673             throw new MetadataRepositoryException( e.getMessage(), e );
 674         }
 675
 676         key = new ProjectVersionMetadataModel.KeyBuilder().withRepository( repositoryId ).withNamespace(
 677             namespace ).withProjectId( projectId ).withId( projectVersion ).build();
 678
 679         ProjectVersionMetadataModel projectVersionMetadataModel = getProjectVersionMetadataModelEntityManager().get( key );
 680
 681         if ( projectVersionMetadataModel == null )
 682         {
 683             projectVersionMetadataModel = new ProjectVersionMetadataModel();
 684             projectVersionMetadataModel.setRowId( key );
 685             projectVersionMetadataModel.setProjectId( projectId );
 686             projectVersionMetadataModel.setId( projectVersion );
 687             projectVersionMetadataModel.setNamespace( namespace );
 688
 689             getProjectVersionMetadataModelEntityManager().put( projectVersionMetadataModel );
 690
 691         }
 692
 693         // now facets
 694         updateFacets( artifactMeta, artifactMetadataModel );
 695
 696     }
 697
 698     @Override
 699     public Collection<String> getArtifactVersions( final String repoId, final String namespace, final String projectId,
 700                                                    final String projectVersion )
 701         throws MetadataResolutionException
 702     {
 703         final Set<String> versions = new HashSet<String>();
 704         // FIXME use cql query
 705         getArtifactMetadataModelEntityManager().visitAll( new Function<ArtifactMetadataModel, Boolean>()
 706         {
 707             @Override
 708             public Boolean apply( ArtifactMetadataModel artifactMetadataModel )
 709             {
 710                 if ( artifactMetadataModel != null )
 711                 {
 712                     if ( StringUtils.equals( repoId, artifactMetadataModel.getRepositoryId() ) && StringUtils.equals(
 713                         namespace, artifactMetadataModel.getNamespace() ) && StringUtils.equals( projectId,
 714                                                                                                  artifactMetadataModel.getProject() )
 715                         && StringUtils.equals( projectVersion, artifactMetadataModel.getProjectVersion() ) )
 716                     {
 717                         versions.add( artifactMetadataModel.getVersion() );
 718                     }
 719                 }
 720                 return Boolean.TRUE;
 721             }
 722         } );
 723
 724         return versions;
 725     }
 726
 727     /**
 728      * iterate over available facets to remove/add from the artifactMetadata
 729      *
 730      * @param facetedMetadata
 731      * @param artifactMetadataModel only use for the key
 732      */
 733     private void updateFacets( final FacetedMetadata facetedMetadata,
 734                                final ArtifactMetadataModel artifactMetadataModel )
 735     {
 736
 737         for ( final String facetId : metadataFacetFactories.keySet() )
 738         {
 739             MetadataFacet metadataFacet = facetedMetadata.getFacet( facetId );
 740             if ( metadataFacet == null )
 741             {
 742                 continue;
 743             }
 744             // clean first
 745
 746             final List<MetadataFacetModel> metadataFacetModels = new ArrayList<MetadataFacetModel>();
 747
 748             getMetadataFacetModelEntityManager().visitAll( new Function<MetadataFacetModel, Boolean>()
 749             {
 750                 @Override
 751                 public Boolean apply( MetadataFacetModel metadataFacetModel )
 752                 {
 753                     ArtifactMetadataModel tmp = metadataFacetModel.getArtifactMetadataModel();
 754                     if ( StringUtils.equals( metadataFacetModel.getFacetId(), facetId ) && StringUtils.equals(
 755                         tmp.getRepositoryId(), artifactMetadataModel.getRepositoryId() ) && StringUtils.equals(
 756                         tmp.getNamespace(), artifactMetadataModel.getNamespace() ) && StringUtils.equals(
 757                         tmp.getProject(), artifactMetadataModel.getProject() ) )
 758                     {
 759                         metadataFacetModels.add( metadataFacetModel );
 760                     }
 761                     return Boolean.TRUE;
 762                 }
 763             } );
 764
 765             getMetadataFacetModelEntityManager().remove( metadataFacetModels );
 766
 767             Map<String, String> properties = metadataFacet.toProperties();
 768
 769             final List<MetadataFacetModel> metadataFacetModelsToAdd =
 770                 new ArrayList<MetadataFacetModel>( properties.size() );
 771
 772             for ( Map.Entry<String, String> entry : properties.entrySet() )
 773             {
 774                 String key = new MetadataFacetModel.KeyBuilder().withKey( entry.getKey() ).withArtifactMetadataModel(
 775                     artifactMetadataModel ).withFacetId( facetId ).withName( metadataFacet.getName() ).build();
 776                 MetadataFacetModel metadataFacetModel =
 777                     new MetadataFacetModel( key, artifactMetadataModel, facetId, entry.getKey(), entry.getValue(),
 778                                             metadataFacet.getName() );
 779                 metadataFacetModelsToAdd.add( metadataFacetModel );
 780             }
 781
 782             getMetadataFacetModelEntityManager().put( metadataFacetModelsToAdd );
 783
 784         }
 785     }
 786
 787     @Override
 788     public void updateProjectVersion( String repositoryId, String namespaceId, String projectId,
 789                                       ProjectVersionMetadata versionMetadata )
 790         throws MetadataRepositoryException
 791     {
 792         String namespaceKey =
 793             new Namespace.KeyBuilder().withRepositoryId( repositoryId ).withNamespace( namespaceId ).build();
 794         Namespace namespace = getNamespaceEntityManager().get( namespaceKey );
 795         if ( namespace == null )
 796         {
 797             namespace = updateOrAddNamespace( repositoryId, namespaceId );
 798         }
 799
 800         String key = new Project.KeyBuilder().withNamespace( namespace ).withProjectId( projectId ).build();
 801
 802         Project project = getProjectEntityManager().get( key );
 803         if ( project == null )
 804         {
 805             project = new Project( key, projectId, namespace );
 806             getProjectEntityManager().put( project );
 807         }
 808
 809         // we don't test of repository and namespace really exist !
 810         key = new ProjectVersionMetadataModel.KeyBuilder().withRepository( repositoryId ).withNamespace(
 811             namespaceId ).withProjectId( projectId ).withId( versionMetadata.getId() ).build();
 812
 813         ProjectVersionMetadataModel projectVersionMetadataModel = getProjectVersionMetadataModelEntityManager().get( key );
 814
 815         if ( projectVersionMetadataModel == null )
 816         {
 817             projectVersionMetadataModel =
 818                 new BeanReplicator().replicateBean( versionMetadata, ProjectVersionMetadataModel.class );
 819             projectVersionMetadataModel.setRowId( key );
 820         }
 821         projectVersionMetadataModel.setProjectId( projectId );
 822         projectVersionMetadataModel.setNamespace( new Namespace( namespaceId, new Repository( repositoryId ) ) );
 823         projectVersionMetadataModel.setCiManagement( versionMetadata.getCiManagement() );
 824         projectVersionMetadataModel.setIssueManagement( versionMetadata.getIssueManagement() );
 825         projectVersionMetadataModel.setOrganization( versionMetadata.getOrganization() );
 826         projectVersionMetadataModel.setScm( versionMetadata.getScm() );
 827
 828         projectVersionMetadataModel.setMailingLists( versionMetadata.getMailingLists() );
 829         projectVersionMetadataModel.setDependencies( versionMetadata.getDependencies() );
 830         projectVersionMetadataModel.setLicenses( versionMetadata.getLicenses() );
 831
 832
 833         try
 834         {
 835             getProjectVersionMetadataModelEntityManager().put( projectVersionMetadataModel );
 836
 837             ArtifactMetadataModel artifactMetadataModel = new ArtifactMetadataModel();
 838             artifactMetadataModel.setArtifactMetadataModelId(
 839                 new ArtifactMetadataModel.KeyBuilder().withId( versionMetadata.getId() ).withRepositoryId(
 840                     repositoryId ).withNamespace( namespaceId ).withProjectVersion(
 841                     versionMetadata.getVersion() ).build() );
 842             artifactMetadataModel.setRepositoryId( repositoryId );
 843             artifactMetadataModel.setNamespace( namespaceId );
 844             artifactMetadataModel.setProject( projectId );
 845             artifactMetadataModel.setProjectVersion( versionMetadata.getVersion() );
 846             artifactMetadataModel.setVersion( versionMetadata.getVersion() );
 847             // facets etc...
 848             updateFacets( versionMetadata, artifactMetadataModel );
 849         }
 850         catch ( PersistenceException e )
 851         {
 852             throw new MetadataRepositoryException( e.getMessage(), e );
 853         }
 854     }
 855
 856
 857     private static class BooleanHolder
 858     {
 859         private boolean value = false;
 860     }
 861
 862     @Override
 863     public List<String> getMetadataFacets( final String repositoryId, final String facetId )
 864         throws MetadataRepositoryException
 865     {
 866         // FIXME use cql query !!
 867         final List<String> facets = new ArrayList<String>();
 868         this.getMetadataFacetModelEntityManager().visitAll( new Function<MetadataFacetModel, Boolean>()
 869         {
 870             @Override
 871             public Boolean apply( MetadataFacetModel metadataFacetModel )
 872             {
 873                 if ( metadataFacetModel != null )
 874                 {
 875                     if ( StringUtils.equals( metadataFacetModel.getArtifactMetadataModel().getRepositoryId(),
 876                                              repositoryId ) && StringUtils.equals( metadataFacetModel.getFacetId(),
 877                                                                                    facetId ) )
 878                     {
 879                         facets.add( metadataFacetModel.getName() );
 880                     }
 881                 }
 882                 return Boolean.TRUE;
 883             }
 884         } );
 885
 886         return facets;
 887
 888     }
 889
 890     @Override
 891     public boolean hasMetadataFacet( String repositoryId, String facetId )
 892         throws MetadataRepositoryException
 893     {
 894         return !getMetadataFacets( repositoryId, facetId ).isEmpty();
 895     }
 896
 897     @Override
 898     public MetadataFacet getMetadataFacet( final String repositoryId, final String facetId, final String name )
 899         throws MetadataRepositoryException
 900     {
 901         // FIXME use cql query !!
 902         final List<MetadataFacetModel> facets = new ArrayList<MetadataFacetModel>();
 903         this.getMetadataFacetModelEntityManager().visitAll( new Function<MetadataFacetModel, Boolean>()
 904         {
 905             @Override
 906             public Boolean apply( MetadataFacetModel metadataFacetModel )
 907             {
 908                 if ( metadataFacetModel != null )
 909                 {
 910                     if ( StringUtils.equals( metadataFacetModel.getArtifactMetadataModel().getRepositoryId(),
 911                                              repositoryId ) && StringUtils.equals( metadataFacetModel.getFacetId(),
 912                                                                                    facetId ) && StringUtils.equals(
 913                         metadataFacetModel.getName(), name ) )
 914                     {
 915                         facets.add( metadataFacetModel );
 916                     }
 917                 }
 918                 return Boolean.TRUE;
 919             }
 920         } );
 921
 922         if ( facets.isEmpty() )
 923         {
 924             return null;
 925         }
 926
 927         MetadataFacetFactory metadataFacetFactory = metadataFacetFactories.get( facetId );
 928         if ( metadataFacetFactory == null )
 929         {
 930             return null;
 931         }
 932         MetadataFacet metadataFacet = metadataFacetFactory.createMetadataFacet( repositoryId, name );
 933         Map<String, String> map = new HashMap<String, String>( facets.size() );
 934         for ( MetadataFacetModel metadataFacetModel : facets )
 935         {
 936             map.put( metadataFacetModel.getKey(), metadataFacetModel.getValue() );
 937         }
 938         metadataFacet.fromProperties( map );
 939         return metadataFacet;
 940     }
 941
 942     @Override
 943     public void addMetadataFacet( String repositoryId, MetadataFacet metadataFacet )
 944         throws MetadataRepositoryException
 945     {
 946
 947         if ( metadataFacet == null )
 948         {
 949             return;
 950         }
 951
 952         if ( metadataFacet.toProperties().isEmpty() )
 953         {
 954             String key = new MetadataFacetModel.KeyBuilder().withRepositoryId( repositoryId ).withFacetId(
 955                 metadataFacet.getFacetId() ).withName( metadataFacet.getName() ).build();
 956             MetadataFacetModel metadataFacetModel = getMetadataFacetModelEntityManager().get( key );
 957             if ( metadataFacetModel == null )
 958             {
 959                 metadataFacetModel = new MetadataFacetModel();
 960             }
 961             // we need to store the repositoryId
 962             ArtifactMetadataModel artifactMetadataModel = new ArtifactMetadataModel();
 963             artifactMetadataModel.setRepositoryId( repositoryId );
 964             metadataFacetModel.setArtifactMetadataModel( artifactMetadataModel );
 965             metadataFacetModel.setId( key );
 966             metadataFacetModel.setFacetId( metadataFacet.getFacetId() );
 967             metadataFacetModel.setName( metadataFacet.getName() );
 968
 969             try
 970             {
 971                 getMetadataFacetModelEntityManager().put( metadataFacetModel );
 972             }
 973             catch ( PersistenceException e )
 974             {
 975                 throw new MetadataRepositoryException( e.getMessage(), e );
 976             }
 977         }
 978         else
 979         {
 980             for ( Map.Entry<String, String> entry : metadataFacet.toProperties().entrySet() )
 981             {
 982
 983                 String key = new MetadataFacetModel.KeyBuilder().withRepositoryId( repositoryId ).withFacetId(
 984                     metadataFacet.getFacetId() ).withName( metadataFacet.getName() ).withKey( entry.getKey() ).build();
 985
 986                 MetadataFacetModel metadataFacetModel = getMetadataFacetModelEntityManager().get( key );
 987                 if ( metadataFacetModel == null )
 988                 {
 989                     metadataFacetModel = new MetadataFacetModel();
 990                     // we need to store the repositoryId
 991                     ArtifactMetadataModel artifactMetadataModel = new ArtifactMetadataModel();
 992                     artifactMetadataModel.setRepositoryId( repositoryId );
 993                     metadataFacetModel.setArtifactMetadataModel( artifactMetadataModel );
 994                     metadataFacetModel.setId( key );
 995                     metadataFacetModel.setKey( entry.getKey() );
 996                     metadataFacetModel.setFacetId( metadataFacet.getFacetId() );
 997                     metadataFacetModel.setName( metadataFacet.getName() );
 998                 }
 999                 metadataFacetModel.setValue( entry.getValue() );
1000                 try
1001                 {
1002                     getMetadataFacetModelEntityManager().put( metadataFacetModel );
1003                 }
1004                 catch ( PersistenceException e )
1005                 {
1006                     throw new MetadataRepositoryException( e.getMessage(), e );
1007                 }
1008
1009             }
1010         }
1011     }
1012
1013     @Override
1014     public void removeMetadataFacets( final String repositoryId, final String facetId )
1015         throws MetadataRepositoryException
1016     {
1017         logger.debug( "removeMetadataFacets repositoryId: '{}', facetId: '{}'", repositoryId, facetId );
1018         final List<MetadataFacetModel> toRemove = new ArrayList<MetadataFacetModel>();
1019
1020         // FIXME cql query
1021         getMetadataFacetModelEntityManager().visitAll( new Function<MetadataFacetModel, Boolean>()
1022         {
1023             @Override
1024             public Boolean apply( MetadataFacetModel metadataFacetModel )
1025             {
1026                 if ( metadataFacetModel != null )
1027                 {
1028                     if ( StringUtils.equals( metadataFacetModel.getArtifactMetadataModel().getRepositoryId(),
1029                                              repositoryId ) && StringUtils.equals( metadataFacetModel.getFacetId(),
1030                                                                                    facetId ) )
1031                     {
1032                         toRemove.add( metadataFacetModel );
1033                     }
1034                 }
1035                 return Boolean.TRUE;
1036             }
1037         } );
1038         logger.debug( "removeMetadataFacets repositoryId: '{}', facetId: '{}', toRemove: {}", repositoryId, facetId,
1039                       toRemove );
1040         getMetadataFacetModelEntityManager().remove( toRemove );
1041     }
1042
1043     @Override
1044     public void removeMetadataFacet( final String repositoryId, final String facetId, final String name )
1045         throws MetadataRepositoryException
1046     {
1047         logger.debug( "removeMetadataFacets repositoryId: '{}', facetId: '{}'", repositoryId, facetId );
1048         final List<MetadataFacetModel> toRemove = new ArrayList<MetadataFacetModel>();
1049
1050         // FIXME cql query
1051         getMetadataFacetModelEntityManager().visitAll( new Function<MetadataFacetModel, Boolean>()
1052         {
1053             @Override
1054             public Boolean apply( MetadataFacetModel metadataFacetModel )
1055             {
1056                 if ( metadataFacetModel != null )
1057                 {
1058                     if ( StringUtils.equals( metadataFacetModel.getArtifactMetadataModel().getRepositoryId(),
1059                                              repositoryId ) && StringUtils.equals( metadataFacetModel.getFacetId(),
1060                                                                                    facetId ) && StringUtils.equals(
1061                         metadataFacetModel.getName(), name ) )
1062                     {
1063                         toRemove.add( metadataFacetModel );
1064                     }
1065                 }
1066                 return Boolean.TRUE;
1067             }
1068         } );
1069         logger.debug( "removeMetadataFacets repositoryId: '{}', facetId: '{}', toRemove: {}", repositoryId, facetId,
1070                       toRemove );
1071         getMetadataFacetModelEntityManager().remove( toRemove );
1072     }
1073
1074     @Override
1075     public List<ArtifactMetadata> getArtifactsByDateRange( final String repositoryId, final Date startTime,
1076                                                            final Date endTime )
1077         throws MetadataRepositoryException
1078     {
1079
1080         final List<ArtifactMetadataModel> artifactMetadataModels = new ArrayList<ArtifactMetadataModel>();
1081
1082         // FIXME cql query
1083         getArtifactMetadataModelEntityManager().visitAll( new Function<ArtifactMetadataModel, Boolean>()
1084         {
1085             @Override
1086             public Boolean apply( ArtifactMetadataModel artifactMetadataModel )
1087             {
1088                 if ( artifactMetadataModel != null )
1089                 {
1090                     if ( StringUtils.equals( artifactMetadataModel.getRepositoryId(), repositoryId )
1091                         && artifactMetadataModel.getNamespace() != null &&
1092                         artifactMetadataModel.getProject() != null && artifactMetadataModel.getId() != null )
1093                     {
1094
1095                         Date when = artifactMetadataModel.getWhenGathered();
1096                         if ( ( startTime != null ? when.getTime() >= startTime.getTime() : true ) && ( endTime != null ?
1097                             when.getTime() <= endTime.getTime() : true ) )
1098                         {
1099                             logger.debug( "getArtifactsByDateRange visitAll found: {}", artifactMetadataModel );
1100                             artifactMetadataModels.add( artifactMetadataModel );
1101                         }
1102                     }
1103                 }
1104                 return Boolean.TRUE;
1105             }
1106         } );
1107         List<ArtifactMetadata> artifactMetadatas = new ArrayList<ArtifactMetadata>( artifactMetadataModels.size() );
1108
1109         for ( ArtifactMetadataModel model : artifactMetadataModels )
1110         {
1111             ArtifactMetadata artifactMetadata = new BeanReplicator().replicateBean( model, ArtifactMetadata.class );
1112             populateFacets( artifactMetadata );
1113             artifactMetadatas.add( artifactMetadata );
1114         }
1115
1116         // FIXME facets ?
1117
1118         logger.debug( "getArtifactsByDateRange repositoryId: {}, startTime: {}, endTime: {}, artifactMetadatas: {}",
1119                       repositoryId, startTime, endTime, artifactMetadatas );
1120
1121         return artifactMetadatas;
1122     }
1123
1124     protected void populateFacets( final ArtifactMetadata artifactMetadata )
1125     {
1126         final List<MetadataFacetModel> metadataFacetModels = new ArrayList<MetadataFacetModel>();
1127
1128         getMetadataFacetModelEntityManager().visitAll( new Function<MetadataFacetModel, Boolean>()
1129         {
1130             @Override
1131             public Boolean apply( MetadataFacetModel metadataFacetModel )
1132             {
1133                 if ( metadataFacetModel != null )
1134                 {
1135                     ArtifactMetadataModel artifactMetadataModel = metadataFacetModel.getArtifactMetadataModel();
1136                     if ( artifactMetadataModel != null )
1137                     {
1138                         if ( StringUtils.equals( artifactMetadata.getRepositoryId(),
1139                                                  artifactMetadataModel.getRepositoryId() ) && StringUtils.equals(
1140                             artifactMetadata.getNamespace(), artifactMetadataModel.getNamespace() )
1141                             && StringUtils.equals( artifactMetadata.getRepositoryId(),
1142                                                    artifactMetadataModel.getRepositoryId() ) && StringUtils.equals(
1143                             artifactMetadata.getProject(), artifactMetadataModel.getProject() ) && StringUtils.equals(
1144                             artifactMetadata.getId(), artifactMetadataModel.getId() ) )
1145                         {
1146                             metadataFacetModels.add( metadataFacetModel );
1147                         }
1148                     }
1149                 }
1150                 return Boolean.TRUE;
1151             }
1152         } );
1153         Map<String, Map<String, String>> facetValuesPerFacet = new HashMap<String, Map<String, String>>();
1154
1155         for ( MetadataFacetModel model : metadataFacetModels )
1156         {
1157             Map<String, String> values = facetValuesPerFacet.get( model.getName() );
1158             if ( values == null )
1159             {
1160                 values = new HashMap<String, String>();
1161             }
1162             values.put( model.getKey(), model.getValue() );
1163             facetValuesPerFacet.put( model.getName(), values );
1164         }
1165
1166         for ( Map.Entry<String, Map<String, String>> entry : facetValuesPerFacet.entrySet() )
1167         {
1168             MetadataFacetFactory factory = metadataFacetFactories.get( entry.getKey() );
1169             if ( factory == null )
1170             {
1171                 continue;
1172             }
1173             MetadataFacet metadataFacet =
1174                 factory.createMetadataFacet( artifactMetadata.getRepositoryId(), entry.getKey() );
1175             metadataFacet.fromProperties( entry.getValue() );
1176             artifactMetadata.addFacet( metadataFacet );
1177         }
1178     }
1179
1180     @Override
1181     public List<ArtifactMetadata> getArtifactsByChecksum( final String repositoryId, final String checksum )
1182         throws MetadataRepositoryException
1183     {
1184         final List<ArtifactMetadataModel> artifactMetadataModels = new ArrayList<ArtifactMetadataModel>();
1185
1186         if ( logger.isDebugEnabled() )
1187         {
1188             logger.debug( "all ArtifactMetadataModel: {}", getArtifactMetadataModelEntityManager().getAll() );
1189         }
1190
1191         // FIXME cql query
1192         getArtifactMetadataModelEntityManager().visitAll( new Function<ArtifactMetadataModel, Boolean>()
1193         {
1194             @Override
1195             public Boolean apply( ArtifactMetadataModel artifactMetadataModel )
1196             {
1197                 if ( artifactMetadataModel != null )
1198                 {
1199                     if ( StringUtils.equals( artifactMetadataModel.getRepositoryId(), repositoryId )
1200                         && artifactMetadataModel.getNamespace() != null &&
1201                         artifactMetadataModel.getProject() != null && artifactMetadataModel.getId() != null )
1202                     {
1203
1204                         if ( StringUtils.equals( checksum, artifactMetadataModel.getMd5() ) || StringUtils.equals(
1205                             checksum, artifactMetadataModel.getSha1() ) )
1206                         {
1207                             artifactMetadataModels.add( artifactMetadataModel );
1208                         }
1209                     }
1210                 }
1211                 return Boolean.TRUE;
1212             }
1213         } );
1214         List<ArtifactMetadata> artifactMetadatas = new ArrayList<ArtifactMetadata>( artifactMetadataModels.size() );
1215
1216         for ( ArtifactMetadataModel model : artifactMetadataModels )
1217         {
1218             ArtifactMetadata artifactMetadata = new BeanReplicator().replicateBean( model, ArtifactMetadata.class );
1219             populateFacets( artifactMetadata );
1220             artifactMetadatas.add( artifactMetadata );
1221         }
1222
1223         logger.debug( "getArtifactsByChecksum repositoryId: {}, checksum: {}, artifactMetadatas: {}", repositoryId,
1224                       checksum, artifactMetadatas );
1225
1226         return artifactMetadatas;
1227     }
1228
1229     @Override
1230     public void removeArtifact( final String repositoryId, final String namespace, final String project,
1231                                 final String version, final String id )
1232         throws MetadataRepositoryException
1233     {
1234         logger.debug( "removeArtifact repositoryId: '{}', namespace: '{}', project: '{}', version: '{}', id: '{}'",
1235                       repositoryId, namespace, project, version, id );
1236         String key =
1237             new ArtifactMetadataModel.KeyBuilder().withRepositoryId( repositoryId ).withNamespace( namespace ).withId(
1238                 id ).withProjectVersion( version ).withProject( project ).build();
1239
1240         ArtifactMetadataModel artifactMetadataModel = new ArtifactMetadataModel();
1241         artifactMetadataModel.setArtifactMetadataModelId( key );
1242
1243         getArtifactMetadataModelEntityManager().remove( artifactMetadataModel );
1244
1245         key =
1246             new ProjectVersionMetadataModel.KeyBuilder().withId( version ).withRepository( repositoryId ).withNamespace(
1247                 namespace ).withProjectId( project ).build();
1248
1249         ProjectVersionMetadataModel projectVersionMetadataModel = new ProjectVersionMetadataModel();
1250         projectVersionMetadataModel.setRowId( key );
1251
1252         getProjectVersionMetadataModelEntityManager().remove( projectVersionMetadataModel );
1253     }
1254
1255     @Override
1256     public void removeArtifact( ArtifactMetadata artifactMetadata, String baseVersion )
1257         throws MetadataRepositoryException
1258     {
1259         logger.debug( "removeArtifact repositoryId: '{}', namespace: '{}', project: '{}', version: '{}', id: '{}'",
1260                       artifactMetadata.getRepositoryId(), artifactMetadata.getNamespace(),
1261                       artifactMetadata.getProject(), baseVersion, artifactMetadata.getId() );
1262         String key =
1263             new ArtifactMetadataModel.KeyBuilder().withRepositoryId( artifactMetadata.getRepositoryId() ).withNamespace(
1264                 artifactMetadata.getNamespace() ).withId( artifactMetadata.getId() ).withProjectVersion(
1265                 baseVersion ).withProject( artifactMetadata.getProject() ).build();
1266
1267         ArtifactMetadataModel artifactMetadataModel = new ArtifactMetadataModel();
1268         artifactMetadataModel.setArtifactMetadataModelId( key );
1269
1270         getArtifactMetadataModelEntityManager().remove( artifactMetadataModel );
1271     }
1272
1273     @Override
1274     public void removeArtifact( final String repositoryId, final String namespace, final String project,
1275                                 final String version, final MetadataFacet metadataFacet )
1276         throws MetadataRepositoryException
1277     {
1278         final List<ArtifactMetadataModel> artifactMetadataModels = new ArrayList<ArtifactMetadataModel>();
1279         getArtifactMetadataModelEntityManager().visitAll( new Function<ArtifactMetadataModel, Boolean>()
1280         {
1281             @Override
1282             public Boolean apply( ArtifactMetadataModel artifactMetadataModel )
1283             {
1284                 if ( artifactMetadataModel != null )
1285                 {
1286                     if ( StringUtils.equals( repositoryId, artifactMetadataModel.getRepositoryId() )
1287                         && StringUtils.equals( namespace, artifactMetadataModel.getNamespace() ) && StringUtils.equals(
1288                         project, artifactMetadataModel.getProject() ) && StringUtils.equals( project,
1289                                                                                              artifactMetadataModel.getVersion() ) )
1290                     {
1291                         artifactMetadataModels.add( artifactMetadataModel );
1292                     }
1293                 }
1294                 return Boolean.TRUE;
1295             }
1296         } );
1297         getArtifactMetadataModelEntityManager().remove( artifactMetadataModels );
1298         /*
1299         getMetadataFacetModelEntityManager().visitAll( new Function<MetadataFacetModel, Boolean>()
1300         {
1301             @Override
1302             public Boolean apply( MetadataFacetModel metadataFacetModel )
1303             {
1304                 if ( metadataFacetModel != null )
1305                 {
1306                     ArtifactMetadataModel artifactMetadataModel = metadataFacetModel.getArtifactMetadataModel();
1307                     if ( artifactMetadataModel != null )
1308                     {
1309                         if ( StringUtils.equals( repositoryId, artifactMetadataModel.getRepositoryId() )
1310                             && StringUtils.equals( namespace, artifactMetadataModel.getNamespace() )
1311                             && StringUtils.equals( project, artifactMetadataModel.getProject() ) && StringUtils.equals(
1312                             version, artifactMetadataModel.getVersion() ) )
1313                         {
1314                             if ( StringUtils.equals( metadataFacetModel.getFacetId(), metadataFacet.getFacetId() )
1315                                 && StringUtils.equals( metadataFacetModel.getName(), metadataFacet.getName() ) )
1316                             {
1317                                 metadataFacetModels.add( metadataFacetModel );
1318                             }
1319                         }
1320                     }
1321                 }
1322                 return Boolean.TRUE;
1323             }
1324         } );
1325         getMetadataFacetModelEntityManager().remove( metadataFacetModels );
1326         */
1327     }
1328
1329
1330     @Override
1331     public List<ArtifactMetadata> getArtifacts( final String repositoryId )
1332         throws MetadataRepositoryException
1333     {
1334         final List<ArtifactMetadataModel> artifactMetadataModels = new ArrayList<ArtifactMetadataModel>();
1335         // FIXME use cql query !
1336         getArtifactMetadataModelEntityManager().visitAll( new Function<ArtifactMetadataModel, Boolean>()
1337         {
1338             @Override
1339             public Boolean apply( ArtifactMetadataModel artifactMetadataModel )
1340             {
1341                 if ( artifactMetadataModel != null )
1342                 {
1343                     if ( StringUtils.equals( repositoryId, artifactMetadataModel.getRepositoryId() ) )
1344                     {
1345                         artifactMetadataModels.add( artifactMetadataModel );
1346                     }
1347                 }
1348
1349                 return Boolean.TRUE;
1350             }
1351         } );
1352
1353         List<ArtifactMetadata> artifactMetadatas = new ArrayList<ArtifactMetadata>( artifactMetadataModels.size() );
1354
1355         for ( ArtifactMetadataModel model : artifactMetadataModels )
1356         {
1357             ArtifactMetadata artifactMetadata = new BeanReplicator().replicateBean( model, ArtifactMetadata.class );
1358             populateFacets( artifactMetadata );
1359             artifactMetadatas.add( artifactMetadata );
1360         }
1361
1362         return artifactMetadatas;
1363     }
1364
1365     @Override
1366     public ProjectMetadata getProject( final String repoId, final String namespace, final String id )
1367         throws MetadataResolutionException
1368     {
1369         //basically just checking it exists
1370         // FIXME use cql query
1371
1372         final BooleanHolder booleanHolder = new BooleanHolder();
1373
1374         getProjectEntityManager().visitAll( new Function<Project, Boolean>()
1375         {
1376             @Override
1377             public Boolean apply( Project project )
1378             {
1379                 if ( project != null )
1380                 {
1381                     if ( StringUtils.equals( repoId, project.getNamespace().getRepository().getName() )
1382                         && StringUtils.equals( namespace, project.getNamespace().getName() ) && StringUtils.equals( id,
1383                                                                                                                     project.getProjectId() ) )
1384                     {
1385                         booleanHolder.value = true;
1386                     }
1387                 }
1388                 return Boolean.TRUE;
1389             }
1390         } );
1391
1392         if ( !booleanHolder.value )
1393         {
1394             return null;
1395         }
1396
1397         ProjectMetadata projectMetadata = new ProjectMetadata();
1398         projectMetadata.setId( id );
1399         projectMetadata.setNamespace( namespace );
1400
1401         logger.debug( "getProject repoId: {}, namespace: {}, projectId: {} -> {}", repoId, namespace, id,
1402                       projectMetadata );
1403
1404         return projectMetadata;
1405     }
1406
1407     @Override
1408     public ProjectVersionMetadata getProjectVersion( final String repoId, final String namespace,
1409                                                      final String projectId, final String projectVersion )
1410         throws MetadataResolutionException
1411     {
1412         String key = new ProjectVersionMetadataModel.KeyBuilder().withRepository( repoId ).withNamespace(
1413             namespace ).withProjectId( projectId ).withId( projectVersion ).build();
1414
1415         ProjectVersionMetadataModel projectVersionMetadataModel = getProjectVersionMetadataModelEntityManager().get( key );
1416
1417         if ( projectVersionMetadataModel == null )
1418         {
1419             logger.debug(
1420                 "getProjectVersion repoId: '{}', namespace: '{}', projectId: '{}', projectVersion: {} -> not found",
1421                 repoId, namespace, projectId, projectVersion );
1422             return null;
1423         }
1424
1425         ProjectVersionMetadata projectVersionMetadata =
1426             new BeanReplicator().replicateBean( projectVersionMetadataModel, ProjectVersionMetadata.class );
1427
1428         logger.debug( "getProjectVersion repoId: '{}', namespace: '{}', projectId: '{}', projectVersion: {} -> {}",
1429                       repoId, namespace, projectId, projectVersion, projectVersionMetadata );
1430
1431         projectVersionMetadata.setCiManagement( projectVersionMetadataModel.getCiManagement() );
1432         projectVersionMetadata.setIssueManagement( projectVersionMetadataModel.getIssueManagement() );
1433         projectVersionMetadata.setOrganization( projectVersionMetadataModel.getOrganization() );
1434         projectVersionMetadata.setScm( projectVersionMetadataModel.getScm() );
1435
1436         // FIXME complete collections !!
1437
1438         // facets
1439         final List<MetadataFacetModel> metadataFacetModels = new ArrayList<MetadataFacetModel>();
1440         // FIXME use cql query
1441         getMetadataFacetModelEntityManager().visitAll( new Function<MetadataFacetModel, Boolean>()
1442         {
1443             @Override
1444             public Boolean apply( MetadataFacetModel metadataFacetModel )
1445             {
1446                 if ( metadataFacetModel != null )
1447                 {
1448                     if ( StringUtils.equals( repoId, metadataFacetModel.getArtifactMetadataModel().getRepositoryId() )
1449                         && StringUtils.equals( namespace, metadataFacetModel.getArtifactMetadataModel().getNamespace() )
1450                         && StringUtils.equals( projectId, metadataFacetModel.getArtifactMetadataModel().getProject() )
1451                         && StringUtils.equals( projectVersion,
1452                                                metadataFacetModel.getArtifactMetadataModel().getProjectVersion() ) )
1453                     {
1454                         metadataFacetModels.add( metadataFacetModel );
1455                     }
1456                 }
1457                 return Boolean.TRUE;
1458             }
1459         } );
1460         Map<String, Map<String, String>> metadataFacetsPerFacetIds = new HashMap<String, Map<String, String>>();
1461         for ( MetadataFacetModel metadataFacetModel : metadataFacetModels )
1462         {
1463
1464             Map<String, String> metaValues = metadataFacetsPerFacetIds.get( metadataFacetModel.getFacetId() );
1465             if ( metaValues == null )
1466             {
1467                 metaValues = new HashMap<String, String>();
1468                 metadataFacetsPerFacetIds.put( metadataFacetModel.getFacetId(), metaValues );
1469             }
1470             metaValues.put( metadataFacetModel.getKey(), metadataFacetModel.getValue() );
1471
1472         }
1473
1474         if ( !metadataFacetsPerFacetIds.isEmpty() )
1475         {
1476             for ( Map.Entry<String, Map<String, String>> entry : metadataFacetsPerFacetIds.entrySet() )
1477             {
1478                 MetadataFacetFactory metadataFacetFactory = metadataFacetFactories.get( entry.getKey() );
1479                 if ( metadataFacetFactory != null )
1480                 {
1481                     MetadataFacet metadataFacet = metadataFacetFactory.createMetadataFacet( repoId, entry.getKey() );
1482                     metadataFacet.fromProperties( entry.getValue() );
1483                     projectVersionMetadata.addFacet( metadataFacet );
1484                 }
1485             }
1486         }
1487
1488         return projectVersionMetadata;
1489     }
1490
1491
1492     @Override
1493     public Collection<ProjectVersionReference> getProjectReferences( String repoId, String namespace, String projectId,
1494                                                                      String projectVersion )
1495         throws MetadataResolutionException
1496     {
1497         // FIXME implement this
1498         return Collections.emptyList();
1499     }
1500
1501     @Override
1502     public Collection<String> getProjects( final String repoId, final String namespace )
1503         throws MetadataResolutionException
1504     {
1505         final Set<String> projects = new HashSet<String>();
1506
1507         // FIXME use cql query
1508         getProjectEntityManager().visitAll( new Function<Project, Boolean>()
1509         {
1510             @Override
1511             public Boolean apply( Project project )
1512             {
1513                 if ( project != null )
1514                 {
1515                     if ( StringUtils.equals( repoId, project.getNamespace().getRepository().getName() )
1516                         && StringUtils.startsWith( project.getNamespace().getName(), namespace ) )
1517                     {
1518                         projects.add( project.getProjectId() );
1519                     }
1520                 }
1521                 return Boolean.TRUE;
1522             }
1523         } );
1524         /*
1525
1526         getArtifactMetadataModelEntityManager().visitAll( new Function<ArtifactMetadataModel, Boolean>()
1527         {
1528             @Override
1529             public Boolean apply( ArtifactMetadataModel artifactMetadataModel )
1530             {
1531                 if ( artifactMetadataModel != null )
1532                 {
1533                     if ( StringUtils.equals( repoId, artifactMetadataModel.getRepositoryId() ) && StringUtils.equals(
1534                         namespace, artifactMetadataModel.getNamespace() ) )
1535                     {
1536                         projects.add( artifactMetadataModel.getProject() );
1537                     }
1538                 }
1539                 return Boolean.TRUE;
1540             }
1541         } );
1542         */
1543         return projects;
1544     }
1545
1546
1547     @Override
1548     public void removeProjectVersion( final String repoId, final String namespace, final String projectId,
1549                                       final String projectVersion )
1550         throws MetadataRepositoryException
1551     {
1552
1553         final List<ArtifactMetadataModel> artifactMetadataModels = new ArrayList<ArtifactMetadataModel>();
1554
1555         // FIXME use cql query
1556
1557         getArtifactMetadataModelEntityManager().visitAll( new Function<ArtifactMetadataModel, Boolean>()
1558         {
1559             @Override
1560             public Boolean apply( ArtifactMetadataModel artifactMetadataModel )
1561             {
1562                 if ( artifactMetadataModel != null )
1563                 {
1564                     if ( StringUtils.equals( repoId, artifactMetadataModel.getRepositoryId() ) && StringUtils.equals(
1565                         namespace, artifactMetadataModel.getNamespace() ) && StringUtils.equals( projectId,
1566                                                                                                  artifactMetadataModel.getProject() )
1567                         && StringUtils.equals( projectVersion, artifactMetadataModel.getProjectVersion() ) )
1568                     {
1569                         artifactMetadataModels.add( artifactMetadataModel );
1570                     }
1571                 }
1572                 return Boolean.TRUE;
1573             }
1574         } );
1575
1576         logger.debug( "removeProjectVersions:{}", artifactMetadataModels );
1577         if ( artifactMetadataModels.isEmpty() )
1578         {
1579             return;
1580         }
1581
1582         getArtifactMetadataModelEntityManager().remove( artifactMetadataModels );
1583
1584         String key = new ProjectVersionMetadataModel.KeyBuilder().withProjectId( projectId ).withId(
1585             projectVersion ).withRepository( repoId ).withNamespace( namespace ).build();
1586
1587         ProjectVersionMetadataModel projectVersionMetadataModel = new ProjectVersionMetadataModel();
1588         projectVersionMetadataModel.setRowId( key );
1589
1590         getProjectVersionMetadataModelEntityManager().remove( projectVersionMetadataModel );
1591     }
1592
1593     @Override
1594     public Collection<ArtifactMetadata> getArtifacts( final String repoId, final String namespace,
1595                                                       final String projectId, final String projectVersion )
1596         throws MetadataResolutionException
1597     {
1598         final List<ArtifactMetadataModel> artifactMetadataModels = new ArrayList<ArtifactMetadataModel>();
1599         // FIXME use cql query !
1600         getArtifactMetadataModelEntityManager().visitAll( new Function<ArtifactMetadataModel, Boolean>()
1601         {
1602             @Override
1603             public Boolean apply( ArtifactMetadataModel artifactMetadataModel )
1604             {
1605                 if ( artifactMetadataModel != null )
1606                 {
1607                     if ( StringUtils.equals( repoId, artifactMetadataModel.getRepositoryId() ) && StringUtils.equals(
1608                         namespace, artifactMetadataModel.getNamespace() ) && StringUtils.equals( projectId,
1609                                                                                                  artifactMetadataModel.getProject() )
1610                         && StringUtils.equals( projectVersion, artifactMetadataModel.getProjectVersion() ) )
1611                     {
1612                         artifactMetadataModels.add( artifactMetadataModel );
1613                     }
1614                 }
1615
1616                 return Boolean.TRUE;
1617             }
1618         } );
1619
1620         List<ArtifactMetadata> artifactMetadatas = new ArrayList<ArtifactMetadata>( artifactMetadataModels.size() );
1621
1622         for ( ArtifactMetadataModel model : artifactMetadataModels )
1623         {
1624             ArtifactMetadata artifactMetadata = new BeanReplicator().replicateBean( model, ArtifactMetadata.class );
1625             populateFacets( artifactMetadata );
1626             artifactMetadatas.add( artifactMetadata );
1627         }
1628
1629         // retrieve facets
1630         final List<MetadataFacetModel> metadataFacetModels = new ArrayList<MetadataFacetModel>();
1631         getMetadataFacetModelEntityManager().visitAll( new Function<MetadataFacetModel, Boolean>()
1632         {
1633             @Override
1634             public Boolean apply( MetadataFacetModel metadataFacetModel )
1635             {
1636                 if ( metadataFacetModel != null )
1637                 {
1638                     if ( StringUtils.equals( repoId, metadataFacetModel.getArtifactMetadataModel().getRepositoryId() )
1639                         && StringUtils.equals( namespace, metadataFacetModel.getArtifactMetadataModel().getNamespace() )
1640                         && StringUtils.equals( projectId, metadataFacetModel.getArtifactMetadataModel().getProject() )
1641                         && StringUtils.equals( projectVersion,
1642                                                metadataFacetModel.getArtifactMetadataModel().getProjectVersion() ) )
1643                     {
1644                         metadataFacetModels.add( metadataFacetModel );
1645                     }
1646
1647                 }
1648                 return Boolean.TRUE;
1649             }
1650         } );
1651
1652         // rebuild MetadataFacet for artifacts
1653
1654         for ( final ArtifactMetadata artifactMetadata : artifactMetadatas )
1655         {
1656             Iterable<MetadataFacetModel> metadataFacetModelIterable =
1657                 Iterables.filter( metadataFacetModels, new Predicate<MetadataFacetModel>()
1658                 {
1659                     @Override
1660                     public boolean apply( MetadataFacetModel metadataFacetModel )
1661                     {
1662                         if ( metadataFacetModel != null )
1663                         {
1664                             return StringUtils.equals( artifactMetadata.getVersion(),
1665                                                        metadataFacetModel.getArtifactMetadataModel().getVersion() );
1666                         }
1667                         return false;
1668                     }
1669                 } );
1670             Iterator<MetadataFacetModel> iterator = metadataFacetModelIterable.iterator();
1671             Map<String, List<MetadataFacetModel>> metadataFacetValuesPerFacetId =
1672                 new HashMap<String, List<MetadataFacetModel>>();
1673             while ( iterator.hasNext() )
1674             {
1675                 MetadataFacetModel metadataFacetModel = iterator.next();
1676                 List<MetadataFacetModel> values = metadataFacetValuesPerFacetId.get( metadataFacetModel.getName() );
1677                 if ( values == null )
1678                 {
1679                     values = new ArrayList<MetadataFacetModel>();
1680                     metadataFacetValuesPerFacetId.put( metadataFacetModel.getFacetId(), values );
1681                 }
1682                 values.add( metadataFacetModel );
1683
1684             }
1685
1686             for ( Map.Entry<String, List<MetadataFacetModel>> entry : metadataFacetValuesPerFacetId.entrySet() )
1687             {
1688                 MetadataFacetFactory metadataFacetFactory = metadataFacetFactories.get( entry.getKey() );
1689                 if ( metadataFacetFactory != null )
1690                 {
1691                     List<MetadataFacetModel> facetModels = entry.getValue();
1692                     if ( !facetModels.isEmpty() )
1693                     {
1694                         MetadataFacet metadataFacet =
1695                             metadataFacetFactory.createMetadataFacet( repoId, facetModels.get( 0 ).getName() );
1696                         Map<String, String> props = new HashMap<String, String>( facetModels.size() );
1697                         for ( MetadataFacetModel metadataFacetModel : facetModels )
1698                         {
1699                             props.put( metadataFacetModel.getKey(), metadataFacetModel.getValue() );
1700                         }
1701                         metadataFacet.fromProperties( props );
1702                         artifactMetadata.addFacet( metadataFacet );
1703                     }
1704                 }
1705             }
1706
1707
1708         }
1709
1710         return artifactMetadatas;
1711     }
1712
1713     @Override
1714     public void save()
1715     {
1716         logger.trace( "save" );
1717     }
1718
1719     @Override
1720     public void close()
1721         throws MetadataRepositoryException
1722     {
1723         logger.trace( "close" );
1724     }
1725
1726     @Override
1727     public void revert()
1728     {
1729         logger.warn( "CassandraMetadataRepository cannot revert" );
1730     }
1731
1732     @Override
1733     public boolean canObtainAccess( Class<?> aClass )
1734     {
1735         return false;
1736     }
1737
1738     @Override
1739     public <T> T obtainAccess( Class<T> aClass )
1740         throws MetadataRepositoryException
1741     {
1742         throw new IllegalArgumentException(
1743             "Access using " + aClass + " is not supported on the cassandra metadata storage" );
1744     }
1745 }