Package jetbrains.buildServer.serverSide.mute

Class BaseLowLevelMutingService<T>

java.lang.Object

jetbrains.buildServer.serverSide.mute.BaseLowLevelMutingService<T>

Direct Known Subclasses:

LowLevelBuildProblemMutingService, LowLevelTestMutingService

public abstract class BaseLowLevelMutingService<T>
extends Object

User: Victory.Bedrosova Date: 11/27/12 Time: 2:53 PM

Since:

8.0

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static class	BaseLowLevelMutingService.AbstractMutesConsumer<T>
static interface	BaseLowLevelMutingService.MutesConsumer<T>

Field Summary

Fields

Modifier and Type	Field	Description
protected ProjectManager	myProjectManager

Constructor Summary

Constructors

Modifier	Constructor	Description
protected	BaseLowLevelMutingService(DBFunctionsProvider DB, ProjectManager projectManager)

Method Summary

Modifier and Type	Method	Description
protected void	addBuildTypesToTT(DBFunctions dbf, Collection<String> buildTypeIds)
protected void	addProjectsToTT(DBFunctions dbf, Collection<String> projectIds)
protected abstract void	doAddProblemsToTT(DBFunctions dbf, Collection<T> problemIds)
protected abstract void	doMuteProblems(DBFunctions dbf, Integer muteId)
protected abstract void	doMuteProblemsInBuild(DBFunctions dbf, Integer muteId, Long buildId, Collection<T> problemIds)
protected abstract void	doMuteProblemsInBuildTypes(DBFunctions dbf, Integer muteId, Collection<String> buildTypeIds, Collection<T> problemIds, boolean removePreviousMutes)
protected abstract void	doMuteProblemsInProject(DBFunctions dbf, Integer muteId, String projectId, Collection<String> projectIdsToUnmute, Collection<String> buildTypeIdsToUnmute, Collection<T> problemIds)
protected abstract void	doUnmuteProblems(DBFunctions dbf, Long buildId, Collection<T> problemIds)
protected abstract void	doUnmuteProblems(DBFunctions dbf, Collection<Integer> muteIds)
protected abstract void	doUnmuteProblemsInProjectsAndBuildTypes(DBFunctions dbf, Collection<String> projectIds, Collection<String> buildTypeIds, Collection<T> problemIds)
protected abstract Map<T,Integer>	getAllMutes(DBFunctions dbf, String buildTypeId)
Collection<T>	getMutedProblems(Integer muteId)
protected abstract Collection<T>	getMutedProblems(DBFunctions dbf, Integer muteId)
Integer	getMuteId(List<String> projectPathIds, String buildTypeId, T problemId)
protected void	invalidateMPLCacheFor(Set<String> projectIds, Collection<String> buildTypes)
void	muteProblemsInBuildExistingMute(Integer muteId, Long buildId, Collection<T> problemIds)
void	muteProblemsInBuildNewMute(Integer muteId, Long buildId, Collection<T> problemIds)
void	muteProblemsInBuildTypes(Integer muteId, String projId, Collection<String> buildTypeIds, Collection<T> problemIds, boolean removePreviousMutes)
void	muteProblemsInProject(Integer muteId, String projId, Set<String> projectIdsToUnmute, Collection<String> buildTypeIdsToUnmute, Collection<T> problemIds)
void	resetMutedProblemsCache()
void	retrieveCurrentMutes(Set<String> projectIds, Set<String> buildTypeIds, BaseLowLevelMutingService.MutesConsumer<T> consumer)	Retrieves all current mutes for the specified project and build types (normally build types are from the specified project)
protected abstract void	retrieveCurrentMutes(DBFunctions dbf, Set<String> projectIds, Set<String> buildTypeIds, BaseLowLevelMutingService.MutesConsumer<T> consumer)
protected abstract void	retrieveCurrentMutes(DBFunctions dbf, T problemId, BaseLowLevelMutingService.MutesConsumer<T> consumer)
void	retrieveCurrentMutes(T problemId, String projectId, Set<String> buildTypeIds, BaseLowLevelMutingService.MutesConsumer<T> consumer)	Retrieves all current mutes for the specified project and build types with specified problem id
void	retrieveMutes(Long buildId, BaseLowLevelMutingService.MutesConsumer<T> consumer)	Retrieves all mutes in specified build
abstract void	retrieveMutes(DBFunctions dbf, Long buildId, BaseLowLevelMutingService.MutesConsumer<T> consumer)
void	retrieveMutesFromBuilds(Collection<Long> buildIds, BaseLowLevelMutingService.MutesConsumer<T> consumer)	Retrieves all mutes in specified builds
protected abstract void	retrieveMutesFromBuilds(DBFunctions dbf, Collection<Long> buildIds, BaseLowLevelMutingService.MutesConsumer<T> consumer)
protected abstract void	retrieveMutesFromBuilds(DBFunctions dbf, T problemId, Collection<Long> buildIds, BaseLowLevelMutingService.MutesConsumer<T> consumer)
void	retrieveMutesFromBuilds(T problemId, Collection<Long> buildIds, BaseLowLevelMutingService.MutesConsumer<T> consumer)	Retrieves all mutes in specified builds with specified problem id
protected abstract void	retrieveMutesWithTimeOut(DBFunctions dbf, BaseLowLevelMutingService.MutesConsumer<T> consumer)
void	retrieveMutesWithTimeOut(BaseLowLevelMutingService.MutesConsumer<T> consumer)	Retrieves all mutes that should be automatically unmuted by now
void	unmuteProblems(Long buildId, Collection<T> problemIds)
void	unmuteProblems(Collection<Integer> muteIds)
void	unmuteProblems(Set<String> projectIds, Set<String> buildTypeIds, Collection<T> problemIds)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

myProjectManager

@NotNull
protected final ProjectManager myProjectManager

Constructor Detail

BaseLowLevelMutingService

protected BaseLowLevelMutingService(@NotNull
                                    DBFunctionsProvider DB,
                                    @NotNull
                                    ProjectManager projectManager)

Method Detail

muteProblemsInBuildNewMute

public void muteProblemsInBuildNewMute(@Nullable
                                       Integer muteId,
                                       @NotNull
                                       Long buildId,
                                       @NotNull
                                       Collection<T> problemIds)

muteProblemsInBuildExistingMute

public void muteProblemsInBuildExistingMute(@Nullable
                                            Integer muteId,
                                            @NotNull
                                            Long buildId,
                                            @NotNull
                                            Collection<T> problemIds)

muteProblemsInBuildTypes

public void muteProblemsInBuildTypes(@NotNull
                                     Integer muteId,
                                     @NotNull
                                     String projId,
                                     @NotNull
                                     Collection<String> buildTypeIds,
                                     @NotNull
                                     Collection<T> problemIds,
                                     boolean removePreviousMutes)

muteProblemsInProject

public void muteProblemsInProject(@NotNull
                                  Integer muteId,
                                  @NotNull
                                  String projId,
                                  @NotNull
                                  Set<String> projectIdsToUnmute,
                                  @NotNull
                                  Collection<String> buildTypeIdsToUnmute,
                                  @NotNull
                                  Collection<T> problemIds)

unmuteProblems

public void unmuteProblems(@NotNull
                           Set<String> projectIds,
                           @NotNull
                           Set<String> buildTypeIds,
                           @NotNull
                           Collection<T> problemIds)

unmuteProblems

public void unmuteProblems(@NotNull
                           Long buildId,
                           @NotNull
                           Collection<T> problemIds)

unmuteProblems

public void unmuteProblems(@NotNull
                           Collection<Integer> muteIds)

doMuteProblemsInBuild

protected abstract void doMuteProblemsInBuild(@NotNull
                                              DBFunctions dbf,
                                              @Nullable
                                              Integer muteId,
                                              @NotNull
                                              Long buildId,
                                              @NotNull
                                              Collection<T> problemIds)

doMuteProblemsInBuildTypes

protected abstract void doMuteProblemsInBuildTypes(@NotNull
                                                   DBFunctions dbf,
                                                   @NotNull
                                                   Integer muteId,
                                                   @NotNull
                                                   Collection<String> buildTypeIds,
                                                   @NotNull
                                                   Collection<T> problemIds,
                                                   boolean removePreviousMutes)

doMuteProblemsInProject

protected abstract void doMuteProblemsInProject(@NotNull
                                                DBFunctions dbf,
                                                @NotNull
                                                Integer muteId,
                                                @NotNull
                                                String projectId,
                                                @NotNull
                                                Collection<String> projectIdsToUnmute,
                                                @NotNull
                                                Collection<String> buildTypeIdsToUnmute,
                                                @NotNull
                                                Collection<T> problemIds)

doMuteProblems

protected abstract void doMuteProblems(@NotNull
                                       DBFunctions dbf,
                                       @NotNull
                                       Integer muteId)

doUnmuteProblemsInProjectsAndBuildTypes

protected abstract void doUnmuteProblemsInProjectsAndBuildTypes(@NotNull
                                                                DBFunctions dbf,
                                                                @NotNull
                                                                Collection<String> projectIds,
                                                                @NotNull
                                                                Collection<String> buildTypeIds,
                                                                @NotNull
                                                                Collection<T> problemIds)

doUnmuteProblems

protected abstract void doUnmuteProblems(@NotNull
                                         DBFunctions dbf,
                                         @NotNull
                                         Collection<Integer> muteIds)

doUnmuteProblems

protected abstract void doUnmuteProblems(@NotNull
                                         DBFunctions dbf,
                                         @NotNull
                                         Long buildId,
                                         @NotNull
                                         Collection<T> problemIds)

doAddProblemsToTT

protected abstract void doAddProblemsToTT(@NotNull
                                          DBFunctions dbf,
                                          @NotNull
                                          Collection<T> problemIds)

invalidateMPLCacheFor

protected void invalidateMPLCacheFor(@NotNull
                                     Set<String> projectIds,
                                     @NotNull
                                     Collection<String> buildTypes)

resetMutedProblemsCache

public void resetMutedProblemsCache()

getAllMutes

@NotNull
protected abstract Map<T,Integer> getAllMutes(@NotNull
                                                    DBFunctions dbf,
                                                    @NotNull
                                                    String buildTypeId)

retrieveCurrentMutes

public void retrieveCurrentMutes(@NotNull
                                 Set<String> projectIds,
                                 @NotNull
                                 Set<String> buildTypeIds,
                                 @NotNull
                                 BaseLowLevelMutingService.MutesConsumer<T> consumer)

Retrieves all current mutes for the specified project and build types (normally build types are from the specified project)

retrieveCurrentMutes

public void retrieveCurrentMutes(@NotNull
                                 T problemId,
                                 @NotNull
                                 String projectId,
                                 @NotNull
                                 Set<String> buildTypeIds,
                                 @NotNull
                                 BaseLowLevelMutingService.MutesConsumer<T> consumer)

Retrieves all current mutes for the specified project and build types with specified problem id

retrieveMutesWithTimeOut

public void retrieveMutesWithTimeOut(@NotNull
                                     BaseLowLevelMutingService.MutesConsumer<T> consumer)

Retrieves all mutes that should be automatically unmuted by now

retrieveMutes

public void retrieveMutes(@NotNull
                          Long buildId,
                          @NotNull
                          BaseLowLevelMutingService.MutesConsumer<T> consumer)

Retrieves all mutes in specified build

retrieveMutesFromBuilds

public void retrieveMutesFromBuilds(@NotNull
                                    Collection<Long> buildIds,
                                    @NotNull
                                    BaseLowLevelMutingService.MutesConsumer<T> consumer)

Retrieves all mutes in specified builds

retrieveMutesFromBuilds

public void retrieveMutesFromBuilds(@NotNull
                                    T problemId,
                                    @NotNull
                                    Collection<Long> buildIds,
                                    @NotNull
                                    BaseLowLevelMutingService.MutesConsumer<T> consumer)

Retrieves all mutes in specified builds with specified problem id

addBuildTypesToTT

protected void addBuildTypesToTT(@NotNull
                                 DBFunctions dbf,
                                 @NotNull
                                 Collection<String> buildTypeIds)

addProjectsToTT

protected void addProjectsToTT(@NotNull
                               DBFunctions dbf,
                               @NotNull
                               Collection<String> projectIds)

retrieveCurrentMutes

protected abstract void retrieveCurrentMutes(@NotNull
                                             DBFunctions dbf,
                                             @NotNull
                                             Set<String> projectIds,
                                             @NotNull
                                             Set<String> buildTypeIds,
                                             @NotNull
                                             BaseLowLevelMutingService.MutesConsumer<T> consumer)

retrieveCurrentMutes

protected abstract void retrieveCurrentMutes(@NotNull
                                             DBFunctions dbf,
                                             @NotNull
                                             T problemId,
                                             @NotNull
                                             BaseLowLevelMutingService.MutesConsumer<T> consumer)

retrieveMutesWithTimeOut

protected abstract void retrieveMutesWithTimeOut(@NotNull
                                                 DBFunctions dbf,
                                                 @NotNull
                                                 BaseLowLevelMutingService.MutesConsumer<T> consumer)

retrieveMutes

public abstract void retrieveMutes(@NotNull
                                   DBFunctions dbf,
                                   @NotNull
                                   Long buildId,
                                   @NotNull
                                   BaseLowLevelMutingService.MutesConsumer<T> consumer)

retrieveMutesFromBuilds

protected abstract void retrieveMutesFromBuilds(@NotNull
                                                DBFunctions dbf,
                                                T problemId,
                                                Collection<Long> buildIds,
                                                BaseLowLevelMutingService.MutesConsumer<T> consumer)

retrieveMutesFromBuilds

protected abstract void retrieveMutesFromBuilds(@NotNull
                                                DBFunctions dbf,
                                                @NotNull
                                                Collection<Long> buildIds,
                                                @NotNull
                                                BaseLowLevelMutingService.MutesConsumer<T> consumer)

getMuteId

@Nullable
public Integer getMuteId(@NotNull
                         List<String> projectPathIds,
                         @NotNull
                         String buildTypeId,
                         @NotNull
                         T problemId)

getMutedProblems

@NotNull
public Collection<T> getMutedProblems(@NotNull
                                      Integer muteId)

getMutedProblems

@NotNull
protected abstract Collection<T> getMutedProblems(@NotNull
                                                  DBFunctions dbf,
                                                  @NotNull
                                                  Integer muteId)