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

   1 package org.apache.maven.archiva.web.action;
   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 java.net.MalformedURLException;
  23 import java.util.ArrayList;
  24 import java.util.Collections;
  25 import java.util.List;
  26 import java.util.Map;
  27
  28 import org.apache.archiva.indexer.search.RepositorySearch;
  29 import org.apache.archiva.indexer.search.RepositorySearchException;
  30 import org.apache.archiva.indexer.util.SearchUtil;
  31 import org.apache.commons.collections.CollectionUtils;
  32 import org.apache.commons.lang.StringUtils;
  33 import org.apache.maven.archiva.configuration.ArchivaConfiguration;
  34 import org.apache.maven.archiva.configuration.ManagedRepositoryConfiguration;
  35 import org.apache.maven.archiva.database.ArchivaDAO;
  36 import org.apache.maven.archiva.database.Constraint;
  37 import org.apache.maven.archiva.database.constraints.ArtifactsByChecksumConstraint;
  38 import org.apache.maven.archiva.indexer.RepositoryIndexException;
  39 import org.apache.maven.archiva.indexer.RepositoryIndexSearchException;
  40 import org.apache.maven.archiva.indexer.search.CrossRepositorySearch;
  41 import org.apache.maven.archiva.indexer.search.SearchResultLimits;
  42 import org.apache.maven.archiva.indexer.search.SearchResults;
  43 import org.apache.maven.archiva.security.AccessDeniedException;
  44 import org.apache.maven.archiva.security.ArchivaSecurityException;
  45 import org.apache.maven.archiva.security.ArchivaXworkUser;
  46 import org.apache.maven.archiva.security.PrincipalNotFoundException;
  47 import org.apache.maven.archiva.security.UserRepositories;
  48
  49 import com.opensymphony.xwork2.ActionContext;
  50 import com.opensymphony.xwork2.Preparable;
  51 import org.apache.maven.archiva.common.utils.VersionUtil;
  52 import org.apache.maven.archiva.database.constraints.UniqueVersionConstraint;
  53 import org.apache.maven.archiva.indexer.search.SearchResultHit;
  54 import org.apache.struts2.ServletActionContext;
  55 import org.springframework.web.context.WebApplicationContext;
  56 import org.springframework.web.context.support.WebApplicationContextUtils;
  57
  58 /**
  59  * Search all indexed fields by the given criteria.
  60  *
  61  * @plexus.component role="com.opensymphony.xwork2.Action" role-hint="searchAction"
  62  */
  63 public class SearchAction
  64     extends PlexusActionSupport
  65     implements Preparable
  66 {
  67     /**
  68      * Query string.
  69      */
  70
  71     private ArchivaConfiguration archivaConfiguration;
  72
  73     private Map<String, ManagedRepositoryConfiguration> managedRepositories;
  74
  75     private String q;
  76
  77     /**
  78      * @plexus.requirement role-hint="jdo"
  79      */
  80     private ArchivaDAO dao;
  81
  82     /**
  83      * The Search Results.
  84      */
  85     private SearchResults results;
  86
  87     /**
  88      * @plexus.requirement role-hint="default"
  89      */
  90     private CrossRepositorySearch crossRepoSearch;
  91
  92     /**
  93      * @plexus.requirement
  94      */
  95     private UserRepositories userRepositories;
  96
  97     /**
  98      * @plexus.requirement
  99      */
 100     private ArchivaXworkUser archivaXworkUser;
 101
 102     private static final String RESULTS = "results";
 103
 104     private static final String ARTIFACT = "artifact";
 105
 106     private List databaseResults;
 107
 108     private int currentPage = 0;
 109
 110     private int totalPages;
 111
 112     private boolean searchResultsOnly;
 113
 114     private String completeQueryString;
 115
 116     private static final String COMPLETE_QUERY_STRING_SEPARATOR = ";";
 117
 118     private List<String> managedRepositoryList;
 119
 120     private String groupId;
 121
 122     private String artifactId;
 123
 124     private String version;
 125
 126     private String className;
 127
 128     private int rowCount = 30;
 129
 130     private String repositoryId;
 131
 132     private boolean fromFilterSearch;
 133
 134     private boolean filterSearch = false;
 135
 136     private boolean fromResultsPage;
 137
 138     private RepositorySearch nexusSearch;
 139
 140     public boolean isFromResultsPage()
 141     {
 142         return fromResultsPage;
 143     }
 144
 145     public void setFromResultsPage( boolean fromResultsPage )
 146     {
 147         this.fromResultsPage = fromResultsPage;
 148     }
 149
 150     public boolean isFromFilterSearch()
 151     {
 152         return fromFilterSearch;
 153     }
 154
 155     public void setFromFilterSearch( boolean fromFilterSearch )
 156     {
 157         this.fromFilterSearch = fromFilterSearch;
 158     }
 159
 160     public void prepare()
 161     {
 162         managedRepositoryList = new ArrayList<String>();
 163         managedRepositoryList = getObservableRepos();
 164
 165         if ( managedRepositoryList.size() > 0 )
 166         {
 167             managedRepositoryList.add( "all" );
 168         }
 169     }
 170
 171     // advanced search MRM-90 -- filtered search
 172     public String filteredSearch()
 173         throws MalformedURLException, RepositoryIndexException, RepositoryIndexSearchException
 174     {
 175         fromFilterSearch = true;
 176
 177         if ( CollectionUtils.isEmpty( managedRepositoryList ) )
 178         {
 179             return GlobalResults.ACCESS_TO_NO_REPOS;
 180         }
 181
 182         SearchResultLimits limits = new SearchResultLimits( currentPage );
 183
 184         limits.setPageSize( rowCount );
 185         List<String> selectedRepos = new ArrayList<String>();
 186
 187         if ( repositoryId.equals( "all" ) )
 188         {
 189             selectedRepos = getObservableRepos();
 190         }
 191         else
 192         {
 193             selectedRepos.add( repositoryId );
 194         }
 195
 196         if ( CollectionUtils.isEmpty( selectedRepos ) )
 197         {
 198             return GlobalResults.ACCESS_TO_NO_REPOS;
 199         }
 200
 201         results =
 202             crossRepoSearch.executeFilteredSearch( getPrincipal(), selectedRepos, groupId, artifactId, version,
 203                                                    className, limits );
 204
 205         if ( results.isEmpty() )
 206         {
 207             addActionError( "No results found" );
 208             return INPUT;
 209         }
 210
 211         totalPages = results.getTotalHits() / limits.getPageSize();
 212
 213         if ( ( results.getTotalHits() % limits.getPageSize() ) != 0 )
 214         {
 215             totalPages = totalPages + 1;
 216         }
 217
 218         for (SearchResultHit hit : results.getHits())
 219         {
 220             final String version = hit.getVersion();
 221             if (version != null)
 222             {
 223                 hit.setVersion(VersionUtil.getBaseVersion(version));
 224             }
 225         }
 226
 227         return SUCCESS;
 228     }
 229
 230     public String quickSearch()
 231         throws MalformedURLException, RepositoryIndexException, RepositoryIndexSearchException
 232     {
 233         /* TODO: give action message if indexing is in progress.
 234          * This should be based off a count of 'unprocessed' artifacts.
 235          * This (yet to be written) routine could tell the user that X (unprocessed) artifacts are not yet
 236          * present in the full text search.
 237          */
 238
 239         assert q != null && q.length() != 0;
 240
 241         fromFilterSearch = false;
 242
 243         SearchResultLimits limits = new SearchResultLimits( currentPage );
 244
 245         List<String> selectedRepos = getObservableRepos();
 246         if ( CollectionUtils.isEmpty( selectedRepos ) )
 247         {
 248             return GlobalResults.ACCESS_TO_NO_REPOS;
 249         }
 250
 251         final boolean isbytecodeSearch = SearchUtil.isBytecodeSearch( q );
 252         if( isbytecodeSearch )
 253         {
 254             results = crossRepoSearch.searchForBytecode( getPrincipal(), selectedRepos, SearchUtil.removeBytecodeKeyword( q ), limits );
 255         }
 256         else
 257         {
 258             if( searchResultsOnly && !completeQueryString.equals( "" ) )
 259             {
 260                 results = crossRepoSearch.searchForTerm( getPrincipal(), selectedRepos, q, limits, parseCompleteQueryString() );
 261             }
 262             else
 263             {
 264                 completeQueryString = "";
 265                 //results = crossRepoSearch.searchForTerm( getPrincipal(), selectedRepos, q, limits );
 266                 try
 267                 {
 268                     results = getNexusSearch().search( getPrincipal(), selectedRepos, q, limits, null );
 269                 }
 270                 catch ( RepositorySearchException e )
 271                 {
 272                     addActionError( e.getMessage() );
 273                     return ERROR;
 274                 }
 275             }
 276         }
 277
 278         if ( results.isEmpty() )
 279         {
 280             addActionError( "No results found" );
 281             return INPUT;
 282         }
 283
 284         totalPages = results.getTotalHits() / limits.getPageSize();
 285
 286         if( (results.getTotalHits() % limits.getPageSize()) != 0 )
 287         {
 288             totalPages = totalPages + 1;
 289         }
 290         // TODO: filter / combine the artifacts by version? (is that even possible with non-artifact hits?)
 291
 292         /* I don't think that we should, as I expect us to utilize the 'score' system in lucene in
 293          * the future to return relevant links better.
 294          * I expect the lucene scoring system to take multiple hits on different areas of a single document
 295          * to result in a higher score.
 296          *   - Joakim
 297          */
 298
 299         if( !isEqualToPreviousSearchTerm( q ) )
 300         {
 301             buildCompleteQueryString( q );
 302         }
 303
 304         if (!isbytecodeSearch)
 305         {
 306             //Lets get the versions for the artifact we just found and display them
 307             //Yes, this is in the lucene index but its more challenging to get them out when we are searching by project
 308             for (SearchResultHit resultHit : results.getHits())
 309             {
 310                 final List<String> versions = dao.query(new UniqueVersionConstraint(getObservableRepos(), resultHit.getGroupId(), resultHit.getArtifactId()));
 311                 if (versions != null && !versions.isEmpty())
 312                 {
 313                     resultHit.setVersion(null);
 314                     resultHit.setVersions(filterTimestampedSnapshots(versions));
 315                 }
 316             }
 317         }
 318
 319         return SUCCESS;
 320     }
 321
 322     /**
 323      * Remove timestamped snapshots from versions
 324      */
 325     private static List<String> filterTimestampedSnapshots(List<String> versions)
 326     {
 327         final List<String> filtered = new ArrayList<String>();
 328         for (final String version : versions)
 329         {
 330             final String baseVersion = VersionUtil.getBaseVersion(version);
 331             if (!filtered.contains(baseVersion))
 332             {
 333                 filtered.add(baseVersion);
 334             }
 335         }
 336         return filtered;
 337     }
 338
 339     public String findArtifact()
 340         throws Exception
 341     {
 342         // TODO: give action message if indexing is in progress
 343
 344         if ( StringUtils.isBlank( q ) )
 345         {
 346             addActionError( "Unable to search for a blank checksum" );
 347             return INPUT;
 348         }
 349
 350         Constraint constraint = new ArtifactsByChecksumConstraint( q );
 351         databaseResults = dao.getArtifactDAO().queryArtifacts( constraint );
 352
 353         if ( databaseResults.isEmpty() )
 354         {
 355             addActionError( "No results found" );
 356             return INPUT;
 357         }
 358
 359         if ( databaseResults.size() == 1 )
 360         {
 361             // 1 hit? return it's information directly!
 362             return ARTIFACT;
 363         }
 364
 365         return RESULTS;
 366     }
 367
 368     public String doInput()
 369     {
 370         return INPUT;
 371     }
 372
 373     private String getPrincipal()
 374     {
 375         return archivaXworkUser.getActivePrincipal( ActionContext.getContext().getSession() );
 376     }
 377
 378     private List<String> getObservableRepos()
 379     {
 380         try
 381         {
 382             return userRepositories.getObservableRepositoryIds( getPrincipal() );
 383         }
 384         catch ( PrincipalNotFoundException e )
 385         {
 386             getLogger().warn( e.getMessage(), e );
 387         }
 388         catch ( AccessDeniedException e )
 389         {
 390             getLogger().warn( e.getMessage(), e );
 391         }
 392         catch ( ArchivaSecurityException e )
 393         {
 394             getLogger().warn( e.getMessage(), e );
 395         }
 396         return Collections.emptyList();
 397     }
 398
 399     private void buildCompleteQueryString( String searchTerm )
 400     {
 401         if ( searchTerm.indexOf( COMPLETE_QUERY_STRING_SEPARATOR ) != -1 )
 402         {
 403             searchTerm = StringUtils.remove( searchTerm, COMPLETE_QUERY_STRING_SEPARATOR );
 404         }
 405
 406         if ( completeQueryString == null || "".equals( completeQueryString ) )
 407         {
 408             completeQueryString = searchTerm;
 409         }
 410         else
 411         {
 412             completeQueryString = completeQueryString + COMPLETE_QUERY_STRING_SEPARATOR + searchTerm;
 413         }
 414     }
 415
 416     private List<String> parseCompleteQueryString()
 417     {
 418         List<String> parsedCompleteQueryString = new ArrayList<String>();
 419         String[] parsed = StringUtils.split( completeQueryString, COMPLETE_QUERY_STRING_SEPARATOR );
 420         CollectionUtils.addAll( parsedCompleteQueryString, parsed );
 421
 422         return parsedCompleteQueryString;
 423     }
 424
 425     private boolean isEqualToPreviousSearchTerm( String searchTerm )
 426     {
 427         if ( !"".equals( completeQueryString ) )
 428         {
 429             String[] parsed = StringUtils.split( completeQueryString, COMPLETE_QUERY_STRING_SEPARATOR );
 430             if ( StringUtils.equalsIgnoreCase( searchTerm, parsed[parsed.length - 1] ) )
 431             {
 432                 return true;
 433             }
 434         }
 435
 436         return false;
 437     }
 438
 439     public String getQ()
 440     {
 441         return q;
 442     }
 443
 444     public void setQ( String q )
 445     {
 446         this.q = q;
 447     }
 448
 449     public SearchResults getResults()
 450     {
 451         return results;
 452     }
 453
 454     public List getDatabaseResults()
 455     {
 456         return databaseResults;
 457     }
 458
 459     public void setCurrentPage( int page )
 460     {
 461         this.currentPage = page;
 462     }
 463
 464     public int getCurrentPage()
 465     {
 466         return currentPage;
 467     }
 468
 469     public int getTotalPages()
 470     {
 471         return totalPages;
 472     }
 473
 474     public void setTotalPages( int totalPages )
 475     {
 476         this.totalPages = totalPages;
 477     }
 478
 479     public boolean isSearchResultsOnly()
 480     {
 481         return searchResultsOnly;
 482     }
 483
 484     public void setSearchResultsOnly( boolean searchResultsOnly )
 485     {
 486         this.searchResultsOnly = searchResultsOnly;
 487     }
 488
 489     public String getCompleteQueryString()
 490     {
 491         return completeQueryString;
 492     }
 493
 494     public void setCompleteQueryString( String completeQueryString )
 495     {
 496         this.completeQueryString = completeQueryString;
 497     }
 498
 499     public ArchivaConfiguration getArchivaConfiguration()
 500     {
 501         return archivaConfiguration;
 502     }
 503
 504     public void setArchivaConfiguration( ArchivaConfiguration archivaConfiguration )
 505     {
 506         this.archivaConfiguration = archivaConfiguration;
 507     }
 508
 509     public Map<String, ManagedRepositoryConfiguration> getManagedRepositories()
 510     {
 511         return getArchivaConfiguration().getConfiguration().getManagedRepositoriesAsMap();
 512     }
 513
 514     public void setManagedRepositories( Map<String, ManagedRepositoryConfiguration> managedRepositories )
 515     {
 516         this.managedRepositories = managedRepositories;
 517     }
 518
 519     public String getGroupId()
 520     {
 521         return groupId;
 522     }
 523
 524     public void setGroupId( String groupId )
 525     {
 526         this.groupId = groupId;
 527     }
 528
 529     public String getArtifactId()
 530     {
 531         return artifactId;
 532     }
 533
 534     public void setArtifactId( String artifactId )
 535     {
 536         this.artifactId = artifactId;
 537     }
 538
 539     public String getVersion()
 540     {
 541         return version;
 542     }
 543
 544     public void setVersion( String version )
 545     {
 546         this.version = version;
 547     }
 548
 549     public int getRowCount()
 550     {
 551         return rowCount;
 552     }
 553
 554     public void setRowCount( int rowCount )
 555     {
 556         this.rowCount = rowCount;
 557     }
 558
 559     public boolean isFilterSearch()
 560     {
 561         return filterSearch;
 562     }
 563
 564     public void setFilterSearch( boolean filterSearch )
 565     {
 566         this.filterSearch = filterSearch;
 567     }
 568
 569     public String getRepositoryId()
 570     {
 571         return repositoryId;
 572     }
 573
 574     public void setRepositoryId( String repositoryId )
 575     {
 576         this.repositoryId = repositoryId;
 577     }
 578
 579     public List<String> getManagedRepositoryList()
 580     {
 581         return managedRepositoryList;
 582     }
 583
 584     public void setManagedRepositoryList( List<String> managedRepositoryList )
 585     {
 586         this.managedRepositoryList = managedRepositoryList;
 587     }
 588
 589     public String getClassName()
 590     {
 591         return className;
 592     }
 593
 594     public void setClassName( String className )
 595     {
 596         this.className = className;
 597     }
 598
 599     public RepositorySearch getNexusSearch()
 600     {
 601         if( nexusSearch == null )
 602         {
 603             WebApplicationContext wac =
 604                 WebApplicationContextUtils.getRequiredWebApplicationContext( ServletActionContext.getServletContext() );
 605             nexusSearch = ( RepositorySearch ) wac.getBean( "nexusSearch" );
 606         }
 607         return nexusSearch;
 608     }
 609
 610     public void setNexusSearch( RepositorySearch nexusSearch )
 611     {
 612         this.nexusSearch = nexusSearch;
 613     }
 614 }