Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2015 JBoss Inc
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * 
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
 */
 
 package org.guvnor.structure.backend.repositories;
 
 import java.util.List;
 import java.util.Map;
 import  javax.enterprise.context.ApplicationScoped;
 import  javax.enterprise.event.Event;
 import  javax.enterprise.event.Observes;
 import  javax.inject.Inject;
 import  javax.inject.Named;
 
 import  org.guvnor.structure.config.SystemRepositoryChangedEvent;
 import  org.guvnor.structure.organizationalunit.OrganizationalUnit;
 import  org.guvnor.structure.organizationalunit.OrganizationalUnitService;
 import  org.guvnor.structure.repositories.NewBranchEvent;
 import  org.guvnor.structure.repositories.NewRepositoryEvent;
 import  org.guvnor.structure.repositories.Repository;
 import  org.guvnor.structure.repositories.RepositoryAlreadyExistsException;
 import  org.guvnor.structure.repositories.RepositoryInfo;
 import  org.guvnor.structure.repositories.RepositoryRemovedEvent;
 import  org.guvnor.structure.repositories.RepositoryService;
 import  org.guvnor.structure.repositories.impl.git.GitRepository;
 import  org.guvnor.structure.server.config.ConfigGroup;
 import  org.guvnor.structure.server.config.ConfigItem;
 import  org.guvnor.structure.server.config.ConfigType;
 import  org.guvnor.structure.server.config.ConfigurationFactory;
 import  org.guvnor.structure.server.config.ConfigurationService;
 import  org.guvnor.structure.server.repositories.RepositoryFactory;
 import  org.jboss.errai.bus.server.annotations.Service;
 import  org.slf4j.Logger;
 import  org.slf4j.LoggerFactory;
 import  org.uberfire.backend.server.util.TextUtil;
 import  org.uberfire.backend.vfs.Path;
 import  org.uberfire.ext.editor.commons.version.impl.PortableVersionRecord;
 import  org.uberfire.io.IOService;
 import  org.uberfire.java.nio.base.version.VersionAttributeView;
 import  org.uberfire.java.nio.base.version.VersionRecord;
 import  org.uberfire.java.nio.file.FileSystem;
 
 import static org.guvnor.structure.backend.repositories.EnvironmentParameters.*;
 import static org.guvnor.structure.server.config.ConfigType.*;
 import static org.uberfire.backend.server.util.Paths.*;
 
 @Service
 @ApplicationScoped
 public class RepositoryServiceImpl implements RepositoryService {
 
     private static final Logger logger = LoggerFactory.getLogger( RepositoryServiceImpl.class );
 
     private static final int HISTORY_PAGE_SIZE = 10;
 
     @Inject
     @Named("ioStrategy")
     private IOService ioService;
 
     @Inject
     @Named("system")
     private Repository systemRepository;
 
     @Inject
     private ConfigurationService configurationService;
 
     @Inject
     private OrganizationalUnitService organizationalUnitService;
 
     @Inject
     private ConfigurationFactory configurationFactory;
 
     @Inject
     private RepositoryFactory repositoryFactory;
 
     @Inject
     private Event<NewRepositoryEvent> event;
 
     @Inject
     private Event<RepositoryRemovedEvent> repositoryRemovedEvent;
 
     @Inject
     private BackwardCompatibleUtil backward;
    private Map<String, Repository> configuredRepositories = new HashMap<String, Repository>();
    private Map<Path, Repository> rootToRepo = new HashMap<Path, Repository>();
    @SuppressWarnings("unchecked")
    public void loadRepositories() {
        final List<ConfigGroup> repoConfigs = .getConfiguration( REPOSITORY );
        if ( !( repoConfigs == null || repoConfigs.isEmpty() ) ) {
            for ( final ConfigGroup config : repoConfigs ) {
                final Repository repository = .newRepository( config );
                .put( repository.getAlias(), repository );
                .put( repository.getRoot(), repository );
                Collection<Stringbranches;
                if ( repository instanceof GitRepository &&
                        ( branches = repository.getBranches() ) != null &&
                        !branches.isEmpty() ) {
                    for ( String branch : branches ) {
                        .put( repository.getBranchRoot( branch ), repository );
                    }
                }
            }
        }
    }
    @Override
    public Repository getRepositoryfinal String alias ) {
        return .get( alias );
    }
    public Repository getRepositoryfinal FileSystem fs ) {
        if ( fs == null ) {
            return null;
        }
        for ( final Repository repository : .values() ) {
            if ( convert( repository.getRoot() ).getFileSystem().equals( fs ) ) {
                return repository;
            }
        }
        if ( convert( .getRoot() ).getFileSystem().equals( fs ) ) {
            return ;
        }
        return null;
    }
    @Override
    public Repository getRepositoryfinal Path root ) {
        // MIGHT NOT FIND IF IN ANOTHER BRANCH!!!!!!
        return .get( root );
    }
    @Override
    public Collection<Repository> getRepositories() {
        return new ArrayList<Repository>( .values() );
    }
    @Override
    public Repository createRepositoryfinal OrganizationalUnit organizationalUnit,
                                        final String scheme,
                                        final String alias,
                                        final Map<StringObjectenv ) throws RepositoryAlreadyExistsException {
        try {
            final Repository repository = createRepositoryschemealiasenv );
            if ( organizationalUnit != null && repository != null ) {
                .addRepository( organizationalUnitrepository );
            }
            return repository;
        } catch ( final Exception e ) {
            .error( "Error during create repository"e );
            throw new RuntimeExceptione );
        }
    }
    @Override
    public Repository createRepositoryfinal String scheme,
                                        final String alias,
                                        final Map<StringObjectenv ) {
        if ( .containsKey( alias ) || ..getAlias().equals( alias ) ) {
            throw new RepositoryAlreadyExistsException( alias );
        }
        Repository repo = null;
        try {
            .startBatch();
            final ConfigGroup repositoryConfig = .newConfigGroup( REPOSITORY, alias"" );
            repositoryConfig.addConfigItem( .newConfigItem( "security:groups"new ArrayList<String>() ) );
            if ( !env.containsKey ) ) {
                repositoryConfig.addConfigItem( .newConfigItem( scheme ) );
            }
            if ( env.containsKey ) ) {
                repositoryConfig.addConfigItem( .newConfigItem( env.get ) ) );
            }
            for ( final Map.Entry<StringObjectentry : env.entrySet() ) {
                if ( entry.getKey().startsWith"crypt:" ) ) {
                    repositoryConfig.addConfigItem( .newSecuredConfigItem( entry.getKey(),
                                                                                               entry.getValue().toString() ) );
                } else {
                    repositoryConfig.addConfigItem( .newConfigItem( entry.getKey(),
                                                                                        entry.getValue() ) );
                }
            }
            repo = createRepositoryrepositoryConfig );
            return repo;
        } catch ( final Exception e ) {
            .error( "Error during create repository"e );
            throw new RuntimeExceptione );
        } finally {
            .endBatch();
            if ( repo != null ) {
                .fire( new NewRepositoryEvent( repo ) );
            }
        }
    }
    //Save the definition
    private Repository createRepositoryfinal ConfigGroup repositoryConfig ) {
        final Repository repository = .newRepository( repositoryConfig );
        .addConfiguration( repositoryConfig );
        .put( repository.getAlias(), repository );
        .put( repository.getRoot(), repository );
        return repository;
    }
    @Override
    public String normalizeRepositoryNameString name ) {
        return TextUtil.normalizeRepositoryName( name );
    }
    @SuppressWarnings({ "unchecked""rawtypes" })
    @Override
    public void addGroup( Repository repository,
                          String group ) {
        final ConfigGroup thisRepositoryConfig = findRepositoryConfigrepository.getAlias() );
        if ( thisRepositoryConfig != null ) {
            final ConfigItem<Listgroups = .compatthisRepositoryConfig ).getConfigItem( "security:groups" );
            groups.getValue().add( group );
            .updateConfiguration( thisRepositoryConfig );
            final Repository updatedRepo = .newRepository( thisRepositoryConfig );
            .put( updatedRepo.getAlias(), updatedRepo );
            .put( updatedRepo.getRoot(), updatedRepo );
        } else {
            throw new IllegalArgumentException"Repository " + repository.getAlias() + " not found" );
        }
    }
    @SuppressWarnings({ "unchecked""rawtypes" })
    @Override
    public void removeGroup( Repository repository,
                             String group ) {
        final ConfigGroup thisRepositoryConfig = findRepositoryConfigrepository.getAlias() );
        if ( thisRepositoryConfig != null ) {
            final ConfigItem<Listgroups = .compatthisRepositoryConfig ).getConfigItem( "security:groups" );
            groups.getValue().remove( group );
            .updateConfiguration( thisRepositoryConfig );
            final Repository updatedRepo = .newRepository( thisRepositoryConfig );
            .put( updatedRepo.getAlias(), updatedRepo );
            .put( updatedRepo.getRoot(), updatedRepo );
        } else {
            throw new IllegalArgumentException"Repository " + repository.getAlias() + " not found" );
        }
    }
    protected ConfigGroup findRepositoryConfigfinal String alias ) {
        final Collection<ConfigGroup> groups = .getConfiguration( ConfigType.REPOSITORY );
        if ( groups != null ) {
            for ( ConfigGroup groupConfig : groups ) {
                if ( groupConfig.getName().equals( alias ) ) {
                    return groupConfig;
                }
            }
        }
        return null;
    }
    @Override
    public void removeRepositoryfinal String alias ) {
        final ConfigGroup thisRepositoryConfig = findRepositoryConfigalias );
        try {
            .startBatch();
            if ( thisRepositoryConfig != null ) {
                .removeConfiguration( thisRepositoryConfig );
            }
            final Repository repo = .remove( alias );
            if ( repo != null ) {
                .remove( repo.getRoot() );
                .fire( new RepositoryRemovedEvent( repo ) );
                .delete( convert( repo.getRoot() ).getFileSystem().getPath( null ) );
            }
            //Remove reference to Repository from Organizational Units
            final Collection<OrganizationalUnit> organizationalUnits = .getOrganizationalUnits();
            for ( OrganizationalUnit ou : organizationalUnits ) {
                for ( Repository repository : ou.getRepositories() ) {
                    if ( repository.getAlias().equals( alias ) ) {
                        .removeRepository( ou,
                                                                    repository );
                    }
                }
            }
        } catch ( final Exception e ) {
            .error( "Error during remove repository"e );
            throw new RuntimeExceptione );
        } finally {
            .endBatch();
        }
    }
    @Override
    public Repository updateRepository( Repository repository,
                                        Map<StringObjectconfig ) {
        final ConfigGroup thisRepositoryConfig = findRepositoryConfigrepository.getAlias() );
        if ( thisRepositoryConfig != null && config != null ) {
            try {
                .startBatch();
                for ( final Map.Entry<StringObjectentry : config.entrySet() ) {
                    ConfigItem configItem = thisRepositoryConfig.getConfigItem( entry.getKey() );
                    if ( configItem == null ) {
                        thisRepositoryConfig.addConfigItem( .newConfigItem( entry.getKey(), entry.getValue() ) );
                    } else {
                        configItem.setValue( entry.getValue() );
                    }
                }
                .updateConfiguration( thisRepositoryConfig );
                final Repository updatedRepo = .newRepository( thisRepositoryConfig );
                .put( updatedRepo.getAlias(), updatedRepo );
                .put( updatedRepo.getRoot(), updatedRepo );
                return updatedRepo;
            } catch ( final Exception e ) {
                .error( "Error during remove repository"e );
                throw new RuntimeExceptione );
            } finally {
                .endBatch();
            }
        } else {
            throw new IllegalArgumentException"Repository " + repository.getAlias() + " not found" );
        }
    }
    public RepositoryInfo getRepositoryInfofinal String alias ) {
        final Repository repo = getRepositoryalias );
        String ouName = null;
        for ( final OrganizationalUnit ou : .getOrganizationalUnits() ) {
            for ( Repository repository : ou.getRepositories() ) {
                if ( repository.getAlias().equals( alias ) ) {
                    ouName = ou.getName();
                }
            }
        }
        List<VersionRecord> initialRecordList = getRepositoryHistoryalias, 0,  );
        return new RepositoryInfo( aliasouNamerepo.getRoot(), repo.getPublicURIs(), initialRecordList );
    }
    @Override
    public List<VersionRecord> getRepositoryHistoryfinal String alias,
                                                     final int startIndex ) {
        return getRepositoryHistoryaliasstartIndexstartIndex +  );
    }
    @Override
    public List<VersionRecord> getRepositoryHistoryAllfinal String alias ) {
        return getRepositoryHistoryalias, 0, -1 );
    }
    @Override
    public List<VersionRecord> getRepositoryHistoryString alias,
                                                     int startIndex,
                                                     int endIndex ) {
        final Repository repo = getRepositoryalias );
        //This is a work-around for https://bugzilla.redhat.com/show_bug.cgi?id=1199215
        //org.kie.workbench.common.screens.contributors.backend.dataset.ContributorsManager is trying to
        //load a Repository's history for a Repository associated with an Organizational Unit before the
        //Repository has been setup.
        if ( repo == null ) {
            return .;
        }
        final VersionAttributeView versionAttributeView = .getFileAttributeView( convert( repo.getRoot() ), VersionAttributeView.class );
        final List<VersionRecord> records = versionAttributeView.readAttributes().history().records();
        if ( startIndex < 0 ) {
            startIndex = 0;
        }
        if ( endIndex < 0 || endIndex > records.size() ) {
            endIndex = records.size();
        }
        if ( startIndex >= records.size() || startIndex >= endIndex ) {
            return Collections.emptyList();
        }
        Collections.reverserecords );
        final List<VersionRecord> result = new ArrayList<VersionRecord>( endIndex - startIndex );
        for ( VersionRecord record : records.subList( startIndexendIndex ) ) {
            result.add( new PortableVersionRecord( record.id(), record.author(), record.email(), record.comment(), record.date(), record.uri() ) );
        }
        return result;
    }
    public void updateRegisteredRepositories( @Observes @org.guvnor.structure.backend.config.Repository SystemRepositoryChangedEvent changedEvent ) {
        flush();
    }
    public void updateBranch( @Observes NewBranchEvent changedEvent ) {
        if ( .containsKey( changedEvent.getRepositoryAlias() ) ) {
            final Repository repository = .get( changedEvent.getRepositoryAlias() );
            if ( repository instanceof GitRepository ) {
                ( (GitRepository) repository ).addBranch( changedEvent.getBranchName(), changedEvent.getBranchPath() );
                .put( changedEvent.getBranchPath(), repository );
            }
        }
    }
    private void flush() {
        .clear();
        loadRepositories();
    }
New to GrepCode? Check out our FAQ X