diff --git a/pom.xml b/pom.xml
index 2c3cb1f38e..8d331e741d 100644
--- a/pom.xml
+++ b/pom.xml
@@ -111,6 +111,11 @@
       <artifactId>mailer</artifactId>
     </dependency>
 
+    <dependency>
+      <groupId>io.jenkins.plugins</groupId>
+      <artifactId>data-tables-api</artifactId>
+    </dependency>
+
     <dependency>
       <groupId>org.jenkins-ci.plugins</groupId>
       <artifactId>junit</artifactId>
diff --git a/src/main/java/hudson/plugins/git/GitSCM.java b/src/main/java/hudson/plugins/git/GitSCM.java
index 5ccac995db..87433e5968 100644
--- a/src/main/java/hudson/plugins/git/GitSCM.java
+++ b/src/main/java/hudson/plugins/git/GitSCM.java
@@ -303,7 +303,7 @@ public Object readResolve() throws IOException, GitException {
         if (remoteRepositories != null && userRemoteConfigs == null) {
             userRemoteConfigs = new ArrayList<>();
             for(RemoteConfig cfg : remoteRepositories) {
-                // converted as in config.jelly
+                // converted as in index.jelly
                 String url = "";
                 if (cfg.getURIs().size() > 0 && cfg.getURIs().get(0) != null)
                     url = cfg.getURIs().get(0).toPrivateString();
diff --git a/src/main/java/jenkins/plugins/git/AbstractGitSCMSource.java b/src/main/java/jenkins/plugins/git/AbstractGitSCMSource.java
index 654807559b..a93794691e 100644
--- a/src/main/java/jenkins/plugins/git/AbstractGitSCMSource.java
+++ b/src/main/java/jenkins/plugins/git/AbstractGitSCMSource.java
@@ -168,6 +168,22 @@ public abstract class AbstractGitSCMSource extends SCMSource {
 
     private static final Logger LOGGER = Logger.getLogger(AbstractGitSCMSource.class.getName());
 
+    static Set<String> cacheEntries = new HashSet<>();
+
+    static {
+        Jenkins jenkins = Jenkins.getInstanceOrNull();
+        if(jenkins != null){
+            File[] caches = new File(jenkins.getRootDir(),"caches").listFiles();
+            if(caches != null) {
+                for (File cache : caches) {
+                    String cacheEntry = cache.getName();
+                    cacheEntries.add(cacheEntry);
+                }
+            }
+            LOGGER.log(Level.FINE,"Caches on Jenkins controller " + cacheEntries);
+        }
+    }
+
     public AbstractGitSCMSource() {
     }
     
@@ -1284,6 +1300,10 @@ protected String getCacheEntry() {
         return getCacheEntry(getRemote());
     }
 
+    protected static Set<String> getCacheEntries(){
+        return cacheEntries;
+    }
+
     protected static File getCacheDir(String cacheEntry) {
         return getCacheDir(cacheEntry, true);
     }
@@ -1298,7 +1318,9 @@ protected static File getCacheDir(String cacheEntry, boolean createDirectory) {
         if (!cacheDir.isDirectory()) {
             if (createDirectory) {
                 boolean ok = cacheDir.mkdirs();
-                if (!ok) {
+                if(ok) {
+                    cacheEntries.add(cacheEntry);
+                }else{
                     LOGGER.log(Level.WARNING, "Failed mkdirs of {0}", cacheDir);
                 }
             } else {
diff --git a/src/main/java/jenkins/plugins/git/maintenance/Cron.java b/src/main/java/jenkins/plugins/git/maintenance/Cron.java
new file mode 100644
index 0000000000..889dc6d340
--- /dev/null
+++ b/src/main/java/jenkins/plugins/git/maintenance/Cron.java
@@ -0,0 +1,42 @@
+package jenkins.plugins.git.maintenance;
+
+import hudson.Extension;
+import hudson.model.PeriodicWork;
+
+import java.util.Calendar;
+import java.util.concurrent.TimeUnit;
+
+@Extension
+public class Cron extends PeriodicWork {
+
+    private TaskScheduler taskScheduler;
+
+    @Override
+    public long getInitialDelay(){
+        return MIN - (Calendar.getInstance().get(Calendar.SECOND) * 1000L);
+    }
+
+    @Override
+    public long getRecurrencePeriod() {
+        return TimeUnit.MINUTES.toMillis(1);
+    }
+
+    @Override
+    protected void doRun(){
+        scheduleMaintenanceTask();
+    }
+
+    void terminateMaintenanceTaskExecution(){
+        if(taskScheduler != null){
+            taskScheduler.terminateMaintenanceTaskExecution();
+        }
+    }
+
+    private void scheduleMaintenanceTask(){
+        if(taskScheduler == null){
+            taskScheduler = new TaskScheduler();
+        }
+
+        taskScheduler.scheduleTasks();
+    }
+}
diff --git a/src/main/java/jenkins/plugins/git/maintenance/GitMaintenanceSCM.java b/src/main/java/jenkins/plugins/git/maintenance/GitMaintenanceSCM.java
new file mode 100644
index 0000000000..701beb1b33
--- /dev/null
+++ b/src/main/java/jenkins/plugins/git/maintenance/GitMaintenanceSCM.java
@@ -0,0 +1,93 @@
+package jenkins.plugins.git.maintenance;
+
+import jenkins.model.Jenkins;
+import jenkins.plugins.git.AbstractGitSCMSource;
+import org.apache.commons.io.FileUtils;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.locks.Lock;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * GitMaintenanceSCM is responsible for fetching all caches along with locks on Jenkins controller. It extends {@link AbstractGitSCMSource}.
+ *
+ * @author Hrushikesh Rao
+ */
+public class GitMaintenanceSCM extends AbstractGitSCMSource {
+
+    String remote;
+
+    private static Logger LOGGER = Logger.getLogger(GitMaintenanceSCM.class.getName());
+    protected GitMaintenanceSCM(String remote){
+        this.remote = remote;
+    }
+
+    /**
+     * Stores the File object and lock for cache.
+     */
+    static class Cache {
+
+        File cache;
+        Lock lock;
+        Cache(File cache, Lock lock){
+            this.cache = cache;
+            this.lock = lock;
+        }
+
+        /**
+         * Return the File object of a cache.
+         * @return File object of a cache.
+         */
+        public File getCacheFile(){
+            return cache;
+        }
+
+        /**
+         * Returns the lock for a cache.
+         *
+         * @return lock for a cache.
+         */
+        public Lock getLock(){
+            return lock;
+        }
+
+    }
+    @Override
+    public String getCredentialsId() {
+        return null;
+    }
+
+    @Override
+    public String getRemote() {
+        return remote;
+    }
+
+    /**
+     * Returns a list of {@link Cache}.
+     * @return A list of {@link Cache}.
+     */
+    public static List<Cache> getCaches(){
+            Jenkins jenkins = Jenkins.getInstanceOrNull();
+
+            List<Cache> caches = new ArrayList<>();
+            if (jenkins == null){
+                LOGGER.log(Level.WARNING,"Internal error. Couldn't get Jenkins instance.");
+                return caches;
+            }
+
+            for (String cacheEntry : getCacheEntries()) {
+                File cacheDir = getCacheDir(cacheEntry,false);
+                Lock cacheLock = getCacheLock(cacheEntry);
+
+                // skip caches size less than 10 mb
+                if(FileUtils.sizeOfDirectory(cacheDir) < 10000000)continue;
+                LOGGER.log(Level.FINE,"Cache Entry " + cacheEntry);
+                caches.add(new Cache(cacheDir,cacheLock));
+            }
+
+            return caches;
+    }
+}
diff --git a/src/main/java/jenkins/plugins/git/maintenance/Logs/CacheRecord.java b/src/main/java/jenkins/plugins/git/maintenance/Logs/CacheRecord.java
new file mode 100644
index 0000000000..8b06f4874e
--- /dev/null
+++ b/src/main/java/jenkins/plugins/git/maintenance/Logs/CacheRecord.java
@@ -0,0 +1,116 @@
+package jenkins.plugins.git.maintenance.Logs;
+
+import jenkins.plugins.git.maintenance.TaskType;
+import org.apache.commons.lang.time.DurationFormatUtils;
+
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+public class CacheRecord {
+    String repoName;
+    long repoSize;
+    String maintenanceType;
+    long timeOfExecution;
+    boolean executionStatus;
+    long executionDuration;
+
+    Map<String,List<CacheRecord>> maintenanceData;
+
+
+    // This is to create a new Cache Record when cache is not present.
+    public CacheRecord(String repoName,String maintenanceType){
+        this.repoName = repoName;
+        this.maintenanceType = maintenanceType;
+        maintenanceData = new HashMap<>();
+
+        for(TaskType taskType : TaskType.values()){
+            maintenanceData.put(taskType.getTaskName(),new LinkedList<>());
+        }
+    }
+
+    // This is to add maintenance data to existing Cache Record
+    public CacheRecord(CacheRecord cacheRecord){
+        setExecutionDuration(cacheRecord.executionDuration);
+        setExecutionStatus(cacheRecord.getExecutionStatus());
+        setRepoSize(cacheRecord.getRepoSize());
+        setTimeOfExecution(cacheRecord.timeOfExecution);
+        setMaintenanceType(cacheRecord.getMaintenanceType());
+    }
+
+
+    public String getRepoName() {
+        return repoName;
+    }
+
+    public long getRepoSize() {
+        return repoSize;
+    }
+    public void setRepoSize(long repoSize) {
+        this.repoSize = repoSize;
+    }
+
+    public String getMaintenanceType() {
+        return maintenanceType;
+    }
+
+    public void setMaintenanceType(String maintenanceType){
+        this.maintenanceType = maintenanceType;
+    }
+
+    public String getTimeOfExecution() {
+        Date date = new Date(timeOfExecution * 1000L);
+        SimpleDateFormat sdf = new SimpleDateFormat("dd-MM-yyyy HH:mm");
+        return sdf.format(date);
+    }
+
+    public void setTimeOfExecution(long timeOfExecution) {
+        this.timeOfExecution = timeOfExecution;
+    }
+
+    public boolean getExecutionStatus() {
+        return executionStatus;
+    }
+
+    public void setExecutionStatus(boolean executionStatus) {
+        this.executionStatus = executionStatus;
+    }
+
+    public String getExecutionDuration() {
+        return DurationFormatUtils.formatDuration(executionDuration,"mmm:ss:SSS");
+    }
+
+    public void setExecutionDuration(long executionDuration) {
+        this.executionDuration = executionDuration;
+    }
+
+    public void insertMaintenanceData(CacheRecord record){
+        if(record != null && maintenanceData != null) {
+            List<CacheRecord> list = maintenanceData.get(record.getMaintenanceType());
+            if(list != null) {
+                list.add(0,record);
+                // Maximum storage of 5 Maintenance Records per Cache.
+                if (list.size() > 5)
+                    list.remove(list.size()-1);
+            }
+        }
+    }
+
+    public List<CacheRecord> getAllMaintenanceRecordsForSingleCache(){
+        List<CacheRecord> maintenanceData = new ArrayList<>();
+
+        for(Map.Entry<String,List<CacheRecord>> entry : this.maintenanceData.entrySet()){
+            maintenanceData.addAll(entry.getValue());
+        }
+
+        Collections.sort(maintenanceData,(o1,o2) -> (int) (o2.timeOfExecution - o1.timeOfExecution));
+
+        return maintenanceData;
+    }
+
+}
diff --git a/src/main/java/jenkins/plugins/git/maintenance/Logs/RecordList.java b/src/main/java/jenkins/plugins/git/maintenance/Logs/RecordList.java
new file mode 100644
index 0000000000..a591fa3f8c
--- /dev/null
+++ b/src/main/java/jenkins/plugins/git/maintenance/Logs/RecordList.java
@@ -0,0 +1,77 @@
+package jenkins.plugins.git.maintenance.Logs;
+
+import java.util.*;
+
+public class RecordList {
+    List<CacheRecord> maintenanceRecords;
+    Set<String> cacheSet;
+
+    public RecordList(){
+        maintenanceRecords = new ArrayList<>();
+        cacheSet = new HashSet<>();
+    }
+
+    List<CacheRecord> getMaintenanceRecords(){
+        return new ArrayList<>(maintenanceRecords);
+    }
+
+    void addRecord(CacheRecord cacheRecord){
+        String repoName = cacheRecord.getRepoName();
+        Set<String> cacheSet = getCacheSet();
+        if(cacheSet.contains(repoName)){
+            // adding record to existing cache list
+            Iterator<CacheRecord> itr = maintenanceRecords.iterator();
+
+            CacheRecord record;
+            while(itr.hasNext()){
+                record = itr.next();
+                if(record.getRepoName().equals(repoName)){
+
+                    // To not lose data of the first maintenance task
+                    if(record.getAllMaintenanceRecordsForSingleCache().size() == 0){
+                        CacheRecord oldCacheRecord = new CacheRecord(record);
+                        record.insertMaintenanceData(oldCacheRecord);
+                    }
+                    CacheRecord childCacheRecord = new CacheRecord(cacheRecord);
+
+                    record.insertMaintenanceData(childCacheRecord);
+
+                    // Updates the Top most Cache with fresh data
+                    record.setTimeOfExecution(childCacheRecord.timeOfExecution);
+                    record.setExecutionStatus(childCacheRecord.getExecutionStatus());
+                    record.setRepoSize(childCacheRecord.getRepoSize());
+                    record.setMaintenanceType(childCacheRecord.getMaintenanceType());
+                    record.setExecutionDuration(childCacheRecord.executionDuration);
+
+                    break;
+                }
+            }
+            return;
+        }
+
+        // Creates a new Cache Entry and adds the data.
+        maintenanceRecords.add(0,cacheRecord);
+        cacheSet.add(repoName);
+    }
+
+    List<CacheRecord> getAllMaintenanceRecordsForSingleCache(String cacheName) {
+        List<CacheRecord> allRecords = null;
+
+        Iterator<CacheRecord> itr = maintenanceRecords.iterator();
+
+        CacheRecord record;
+        while(itr.hasNext()){
+            record = itr.next();
+            if(record.getRepoName().equals(cacheName)){
+                allRecords = record.getAllMaintenanceRecordsForSingleCache();
+                break;
+            }
+        }
+
+        return allRecords;
+    }
+
+    Set<String> getCacheSet(){
+        return this.cacheSet;
+    }
+}
diff --git a/src/main/java/jenkins/plugins/git/maintenance/Logs/XmlSerialize.java b/src/main/java/jenkins/plugins/git/maintenance/Logs/XmlSerialize.java
new file mode 100644
index 0000000000..04ba3ef65a
--- /dev/null
+++ b/src/main/java/jenkins/plugins/git/maintenance/Logs/XmlSerialize.java
@@ -0,0 +1,95 @@
+package jenkins.plugins.git.maintenance.Logs;
+
+import com.thoughtworks.xstream.XStream;
+import com.thoughtworks.xstream.io.xml.DomDriver;
+import com.thoughtworks.xstream.security.AnyTypePermission;
+import jenkins.model.Jenkins;
+import jenkins.plugins.git.maintenance.GitMaintenanceSCM;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+public class XmlSerialize{
+
+    XStream xStream;
+
+    File maintenanceRecordsFile;
+
+    RecordList recordList;
+
+    String maintenanceFileName = "maintenanceRecords.xml";
+    private static Logger LOGGER = Logger.getLogger(GitMaintenanceSCM.class.getName());
+
+    public XmlSerialize(){
+        this.xStream = new XStream(new DomDriver());
+        this.xStream.addPermission(AnyTypePermission.ANY);
+        Jenkins jenkins = Jenkins.getInstanceOrNull();
+
+        if(jenkins != null) {
+            File rootDir = jenkins.getRootDir();
+            this.maintenanceRecordsFile = new File(rootDir.getAbsolutePath(), maintenanceFileName);
+        }
+    }
+
+    RecordList fetchMaintenanceData(){
+        if(maintenanceRecordsFile == null){
+            // Need to log.....
+            LOGGER.log(Level.FINE,maintenanceFileName + " file path error.");
+            return null;
+        }
+
+        // Checks if recordList is loaded from xml. If not loaded, load it.
+        if(recordList == null) {
+            try {
+                RecordList recordList;
+                if (!maintenanceRecordsFile.exists()) {
+                    recordList = new RecordList();
+                    LOGGER.log(Level.FINE,maintenanceFileName + " file doesn't exist");
+                } else {
+                    byte[] parsedXmlByteArr = Files.readAllBytes(Paths.get(maintenanceRecordsFile.getAbsolutePath()));
+                    String parsedXmlString = new String(parsedXmlByteArr, StandardCharsets.UTF_8);
+
+                    xStream.setClassLoader(RecordList.class.getClassLoader());
+                    recordList = (RecordList) xStream.fromXML(parsedXmlString);
+                    LOGGER.log(Level.FINE,"Maintenance data loaded from " + maintenanceFileName);
+                }
+                this.recordList = recordList;
+            } catch (IOException e) {
+                LOGGER.log(Level.FINE,"Couldn't load data from " + maintenanceFileName + ". Err: " + e.getMessage());
+            }
+        }
+
+        return this.recordList;
+    }
+
+    public boolean addMaintenanceRecord(CacheRecord record){
+        RecordList recordList = fetchMaintenanceData();
+
+        if(recordList != null){
+            try {
+
+                recordList.addRecord(record);
+                String xmlData = xStream.toXML(recordList);
+                Files.write(Paths.get(maintenanceRecordsFile.getAbsolutePath()), xmlData.getBytes(StandardCharsets.UTF_8));
+                return true;
+            }catch (IOException e){
+                LOGGER.log(Level.FINE,"Error writing a record to " + maintenanceFileName + ". Err: " + e.getMessage());
+            }
+        }
+        return false;
+    }
+
+    public List<CacheRecord> getMaintenanceRecords(){
+        return fetchMaintenanceData().getMaintenanceRecords();
+    }
+
+    public List<CacheRecord> getAllMaintenanceRecordsForSingleCache(String cacheName) {
+       return fetchMaintenanceData().getAllMaintenanceRecordsForSingleCache(cacheName);
+    }
+}
diff --git a/src/main/java/jenkins/plugins/git/maintenance/MaintenanceTaskConfiguration.java b/src/main/java/jenkins/plugins/git/maintenance/MaintenanceTaskConfiguration.java
new file mode 100644
index 0000000000..0cb2b25500
--- /dev/null
+++ b/src/main/java/jenkins/plugins/git/maintenance/MaintenanceTaskConfiguration.java
@@ -0,0 +1,183 @@
+package jenkins.plugins.git.maintenance;
+
+import antlr.ANTLRException;
+import com.google.common.collect.ImmutableList;
+import edu.umd.cs.findbugs.annotations.NonNull;
+import hudson.Extension;
+import hudson.Launcher;
+import hudson.model.TaskListener;
+import hudson.scheduler.CronTab;
+import hudson.util.StreamTaskListener;
+import jenkins.model.GlobalConfiguration;
+import org.apache.commons.lang3.StringUtils;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.stream.Collectors;
+
+/**
+ * MaintenanceTaskConfiguration is responsible for creating tasks,fetching tasks, storing the configuration in Jenkins. It extends the
+ * <b>{@link GlobalConfiguration}</b> class.
+ *
+ * @author Hrushikesh Rao
+ */
+@Extension
+public class MaintenanceTaskConfiguration extends GlobalConfiguration {
+
+    /**
+     * It is the core data structure which stores all maintenance tasks.
+     * A map ensure the efficient data access. The {@link TaskType} is key and {@link Task} is value.
+     *
+     */
+    private Map<TaskType,Task> maintenanceTasks;
+    private boolean isGitMaintenanceRunning;
+
+    private static final Logger LOGGER = Logger.getLogger(MaintenanceTaskConfiguration.class.getName());
+
+    /**
+     * The constructor checks if a <i>maintenanceTaskConfiguration.xml</i> file is present on Jenkins.
+     * This xml file contains maintenance data configured by the administrator.
+     * If file is present, the data is loaded from the file. The file would be missing if administrators never configured maintenance task on Jenkins.
+     * If file is missing a data structure is created by calling {@link MaintenanceTaskConfiguration#configureMaintenanceTasks()}.
+     *
+     */
+    public MaintenanceTaskConfiguration(){
+
+        LOGGER.log(Level.FINE,"Loading git-maintenance configuration if present on jenkins controller.");
+        load();
+        if(maintenanceTasks == null) {
+            LOGGER.log(Level.FINE,"Git maintenance configuration not present on Jenkins, creating a default configuration");
+            configureMaintenanceTasks();
+            isGitMaintenanceRunning = false;
+        }else{
+            LOGGER.log(Level.FINE,"Loaded git maintenance configuration successfully.");
+        }
+    }
+
+    /**
+     *  Initializes a data structure if configured for first time. The data structure is used to store and fetch maintenance configuration.
+     */
+    private void configureMaintenanceTasks(){
+        // check git version and based on git version, add the maintenance tasks to the list
+        // Can add default cron syntax for maintenance tasks.
+        maintenanceTasks = new LinkedHashMap<>();
+
+        maintenanceTasks.put(TaskType.COMMIT_GRAPH,new Task(TaskType.COMMIT_GRAPH));
+        maintenanceTasks.put(TaskType.PREFETCH,new Task(TaskType.PREFETCH));
+        maintenanceTasks.put(TaskType.GC,new Task(TaskType.GC));
+        maintenanceTasks.put(TaskType.LOOSE_OBJECTS,new Task(TaskType.LOOSE_OBJECTS));
+        maintenanceTasks.put(TaskType.INCREMENTAL_REPACK,new Task(TaskType.INCREMENTAL_REPACK));
+    }
+
+    /**
+     * Gets a copy of list of Maintenance Tasks.
+     *
+     * @return List of {@link Task}.
+     */
+    public List<Task> getMaintenanceTasks(){
+        List<Task> maintenanceTasks = new ArrayList<>();
+        for(Map.Entry<TaskType,Task> entry : this.maintenanceTasks.entrySet()){
+           maintenanceTasks.add(entry.getValue());
+        }
+        return ImmutableList.copyOf(maintenanceTasks);
+    }
+
+    /**
+     * Set the cron Syntax of a maintenance task.
+     *
+     * @param taskType type of maintenance task.
+     * @param cronSyntax cron syntax corresponding to task.
+     */
+    public void setCronSyntax(TaskType taskType, String cronSyntax){
+        Task updatedTask = maintenanceTasks.get(taskType);
+        updatedTask.setCronSyntax(cronSyntax);
+        maintenanceTasks.put(taskType,updatedTask);
+        LOGGER.log(Level.FINE,"Assigned " + cronSyntax + " to " + taskType.getTaskName());
+    }
+
+    /**
+     * Returns the status of git maintenance i.e. is it configured or not.
+     *
+     * @return A boolean if git maintenance is configured globally.
+     */
+    public boolean getIsGitMaintenanceRunning(){
+        return isGitMaintenanceRunning;
+    }
+
+    /**
+     * Set the execution status of git maintenance globally. If false, the git maintenance is not executed on any cache.
+     *
+     * @param executionStatus a boolean to set the global git maintenance.
+     */
+    public void setIsGitMaintenanceRunning(boolean executionStatus){isGitMaintenanceRunning = executionStatus;}
+
+    /**
+     * Maintenance task state can be changed by toggling the isConfigured boolean variable present in {@link Task} class.
+     * If isConfigured is true, the maintenance task is executed when corresponding cronSyntax is valid else task is not executed at all.
+     *
+     * @param taskType The type of maintenance task.
+     * @param isConfigured The state of execution of maintenance Task.
+     */
+    public void setIsTaskConfigured(TaskType taskType, boolean isConfigured){
+        Task task = maintenanceTasks.get(taskType);
+        task.setIsTaskConfigured(isConfigured);
+        LOGGER.log(Level.FINE,taskType.getTaskName() + " execution status: " + isConfigured);
+    }
+
+    /**
+     * Validates the input cron syntax.
+     *
+     * @param cron Cron syntax as String.
+     * @return Empty string if no error, else a msg describing error in cron syntax.
+     * @throws ANTLRException during incorrect cron input.
+     */
+    public static String checkSanity(@NonNull String cron) throws ANTLRException {
+       try {
+           CronTab cronTab = new CronTab(cron.trim());
+           String msg = cronTab.checkSanity();
+           return msg;
+       }catch(ANTLRException e){
+           if(cron.contains("**"))
+               throw new ANTLRException("You appear to be missing whitespace between * and *.");
+           throw new ANTLRException(String.format("Invalid input: \"%s\": %s", cron, e), e);
+       }
+    }
+
+    /**
+     * Returns the git version used for maintenance.
+     *
+     * @return the git version used for maintenance.
+     */
+    static List<Integer> getGitVersion(){
+
+        final TaskListener procListener = StreamTaskListener.fromStderr();
+        final ByteArrayOutputStream out = new ByteArrayOutputStream();
+        try {
+            new Launcher.LocalLauncher(procListener).launch().cmds("git", "--version").stdout(out).join();
+        } catch (IOException | InterruptedException ex) {
+            LOGGER.log(Level.WARNING, "Exception checking git version " + ex);
+        }
+        String versionOutput = "";
+        try {
+            versionOutput = out.toString(StandardCharsets.UTF_8.toString()).trim();
+        } catch (UnsupportedEncodingException ue) {
+            LOGGER.log(Level.WARNING, "Unsupported encoding checking git version", ue);
+        }
+        final String[] fields = versionOutput.split(" ")[2].replaceAll("msysgit.", "").replaceAll("windows.", "").split("\\.");
+
+        // Eg: [2, 31, 4]
+        // 0th index is Major Version.
+        // 1st index is Minor Version.
+        // 2nd index is Patch Version.
+        return Arrays.stream(fields).map(Integer::parseInt).collect(Collectors.toList());
+    }
+}
diff --git a/src/main/java/jenkins/plugins/git/maintenance/MaintenanceUI.java b/src/main/java/jenkins/plugins/git/maintenance/MaintenanceUI.java
new file mode 100644
index 0000000000..746c451060
--- /dev/null
+++ b/src/main/java/jenkins/plugins/git/maintenance/MaintenanceUI.java
@@ -0,0 +1,250 @@
+package jenkins.plugins.git.maintenance;
+
+import antlr.ANTLRException;
+import edu.umd.cs.findbugs.annotations.NonNull;
+import hudson.Extension;
+import hudson.model.ManagementLink;
+import hudson.model.PeriodicWork;
+import hudson.security.Permission;
+import hudson.util.FormValidation;
+import jenkins.model.GlobalConfiguration;
+import jenkins.model.Jenkins;
+import jenkins.plugins.git.maintenance.Logs.CacheRecord;
+import jenkins.plugins.git.maintenance.Logs.XmlSerialize;
+import net.sf.json.JSONArray;
+import net.sf.json.JSONObject;
+import org.kohsuke.accmod.Restricted;
+import org.kohsuke.accmod.restrictions.NoExternalUse;
+import org.kohsuke.stapler.QueryParameter;
+import org.kohsuke.stapler.StaplerRequest;
+import org.kohsuke.stapler.StaplerResponse;
+import org.kohsuke.stapler.bind.JavaScriptMethod;
+import org.kohsuke.stapler.interceptor.RequirePOST;
+import org.kohsuke.stapler.verb.POST;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+@Extension
+public class MaintenanceUI extends ManagementLink {
+
+    JSONObject notification = new JSONObject();
+    String OK = "OK";
+    String ERROR = "ERROR";
+
+    private static final Logger LOGGER = Logger.getLogger(MaintenanceUI.class.getName());
+
+    @Override
+    public String getIconFileName() {
+        return jenkins.model.Jenkins.RESOURCE_PATH + "/plugin/git/icons/git-maintenance.svg";
+    }
+
+    @Override
+    public String getDisplayName() {
+        return "Git Maintenance";
+    }
+
+    @Override
+    public String getUrlName() {
+        return "maintenance";
+    }
+
+    @Override
+    public String getDescription() {
+        return "Maintain your repositories to improve git performance.";
+    }
+
+    public @NonNull String getCategoryName() {
+        return "CONFIGURATION";
+    }
+
+    @RequirePOST
+    @Restricted(NoExternalUse.class)
+    public void doSave(StaplerRequest req, StaplerResponse res) throws IOException, ServletException {
+        if (!Jenkins.get().hasPermission(Jenkins.ADMINISTER)) {
+            LOGGER.log(Level.WARNING,"User doesn't have the required permission to access git-maintenance.");
+            res.sendError(HttpServletResponse.SC_FORBIDDEN);
+            return;
+        }
+
+        JSONObject formData = req.getSubmittedForm();
+        MaintenanceTaskConfiguration config = GlobalConfiguration.all().get(MaintenanceTaskConfiguration.class);
+
+        if(config != null) {
+            for (TaskType taskType : TaskType.values()) {
+                JSONObject maintenanceData = formData.getJSONObject(taskType.toString());
+                String cronSyntax = maintenanceData.getString("cronSyntax");
+                boolean isApplied = maintenanceData.getBoolean("isApplied");
+
+                config.setCronSyntax(taskType, cronSyntax);
+                config.setIsTaskConfigured(taskType, isApplied);
+            }
+            config.save();
+            LOGGER.log(Level.FINE, "Maintenance configuration data stored successfully on Jenkins.");
+            setNotification("Data saved on Jenkins.",OK);
+            res.sendRedirect("");
+            return;
+        }
+        LOGGER.log(Level.WARNING,"Couldn't load Global git maintenance configuration. Internal Error.");
+        setNotification("Internal Error! Data not saved.",ERROR);
+    }
+
+    @RequirePOST
+    @Restricted(NoExternalUse.class)
+    public void doExecuteMaintenanceTask(StaplerRequest req, StaplerResponse res) throws IOException {
+        if (!Jenkins.get().hasPermission(Jenkins.ADMINISTER)) {
+            LOGGER.log(Level.WARNING,"User doesn't have the required permission to access git-maintenance");
+            res.sendError(HttpServletResponse.SC_FORBIDDEN);
+            return;
+        }
+
+        MaintenanceTaskConfiguration config = GlobalConfiguration.all().get(MaintenanceTaskConfiguration.class);
+        if(config != null) {
+
+            // schedule maintenance tasks only if all cron syntax are valid.
+            // else can't schedule maintenance tasks.
+
+            boolean updatedGitMaintenanceExecutionStatus = true;
+            config.setIsGitMaintenanceRunning(updatedGitMaintenanceExecutionStatus);
+            config.save();
+            LOGGER.log(Level.FINE, "Git Maintenance tasks are scheduled for execution.");
+            setNotification("Scheduled Maintenance Tasks.",OK);
+        }else{
+            setNotification("Internal Error! Tasks not scheduled.",ERROR);
+        }
+
+        res.sendRedirect("");
+    }
+
+    @RequirePOST
+    @Restricted(NoExternalUse.class)
+    public void doTerminateMaintenanceTask(StaplerRequest req, StaplerResponse res) throws IOException {
+        if (!Jenkins.get().hasPermission(Jenkins.ADMINISTER)) {
+            LOGGER.log(Level.WARNING,"User doesn't have the required permission to access git-maintenance");
+            res.sendError(HttpServletResponse.SC_FORBIDDEN);
+            return;
+        }
+
+        MaintenanceTaskConfiguration config = GlobalConfiguration.all().get(MaintenanceTaskConfiguration.class);
+        if(config != null) {
+            boolean updatedGitMaintenanceExecutionStatus = false;
+            config.setIsGitMaintenanceRunning(updatedGitMaintenanceExecutionStatus);
+            config.save();
+
+            Cron cron = PeriodicWork.all().get(Cron.class);
+            if (cron != null) {
+                cron.terminateMaintenanceTaskExecution();
+                cron.cancel();
+                LOGGER.log(Level.FINE, "Terminated scheduling of Git Maintenance tasks.");
+                setNotification("Terminated Maintenance Tasks.",OK);
+            } else {
+                LOGGER.log(Level.WARNING, "Couldn't Terminate Maintenance Task. Internal Error.");
+                setNotification("Internal Error! Couldn't Terminate Tasks.",ERROR);
+            }
+        }else{
+            setNotification("Internal Error! Couldn't Terminate Tasks.",ERROR);
+        }
+        res.sendRedirect("");
+    }
+
+    @POST
+    @Restricted(NoExternalUse.class)
+    public FormValidation doCheckCronSyntax(@QueryParameter String cronSyntax) throws ANTLRException {
+        try {
+            Jenkins.get().checkPermission(Jenkins.ADMINISTER);
+            if (cronSyntax.isEmpty())
+                return FormValidation.ok();
+
+            String msg = MaintenanceTaskConfiguration.checkSanity(cronSyntax);
+
+            if (msg != null) {
+                return FormValidation.error(msg);
+            }
+            return FormValidation.ok();
+        }catch(ANTLRException e){
+            return FormValidation.error(e.getMessage());
+        }
+    }
+
+    public List<Task> getMaintenanceTasks(){
+        // Can check if git version doesn't support a maintenance task and remove that maintenance task from the UI.
+        MaintenanceTaskConfiguration config = GlobalConfiguration.all().get(MaintenanceTaskConfiguration.class);
+        if(config != null)
+            return config.getMaintenanceTasks();
+        LOGGER.log(Level.WARNING,"Couldn't load Global git maintenance configuration. Internal Error.");
+        return new ArrayList<>();
+    }
+
+    public boolean getIsGitMaintenanceRunning(){
+        MaintenanceTaskConfiguration config = GlobalConfiguration.all().get(MaintenanceTaskConfiguration.class);
+        if(config != null)
+            return config.getIsGitMaintenanceRunning();
+        LOGGER.log(Level.WARNING,"Couldn't load Global git maintenance configuration. Internal Error.");
+        return false;
+    }
+
+    public String getGitVersion(){
+        List<Integer> gitVersion = MaintenanceTaskConfiguration.getGitVersion();
+        return gitVersion.get(0) + "." + gitVersion.get(1) + "." + gitVersion.get(2);
+    }
+
+    public String updateGitVersionHelperText(){
+        List<Integer> gitVersion = MaintenanceTaskConfiguration.getGitVersion();
+        int gitMajor = gitVersion.get(0);
+        int gitMinor = gitVersion.get(1);
+
+        if((gitMajor == 2 && gitMinor >= 30) || (gitMajor > 2))
+            return "";
+
+        return "Use git version >= 2.30 to get full benefits of git maintenance.";
+    }
+
+    @NonNull
+    @Override
+    public Permission getRequiredPermission() {
+        return Jenkins.ADMINISTER;
+    }
+
+    @JavaScriptMethod
+    public void setNotification(String notification, String type){
+        this.notification.put("msg",notification);
+        this.notification.put("type",type);
+    }
+
+    @JavaScriptMethod
+    public JSONObject getNotification(){
+        // creating a copy...
+        return JSONObject.fromObject(notification.toString());
+    }
+
+    public List<CacheRecord> getMaintenanceRecords(){
+        return new XmlSerialize().getMaintenanceRecords();
+    }
+
+    @JavaScriptMethod
+    public JSONObject getRecordsForSingleCache(String cacheName){
+        List<CacheRecord> allMaintenanceRecordsOfCache = new XmlSerialize().getAllMaintenanceRecordsForSingleCache(cacheName);
+        JSONObject jsonObject = new JSONObject();
+        JSONArray jsonArray = new JSONArray();
+
+        // Converting List of records to Json.
+        for(CacheRecord cacheRecord : allMaintenanceRecordsOfCache){
+            JSONObject cacheObject = new JSONObject();
+            cacheObject.put("maintenanceType",cacheRecord.getMaintenanceType());
+            cacheObject.put("timeOfExecution",cacheRecord.getTimeOfExecution());
+            cacheObject.put("executionStatus",cacheRecord.getExecutionStatus());
+            cacheObject.put("executionDuration",cacheRecord.getExecutionDuration());
+            cacheObject.put("repoSize",cacheRecord.getRepoSize());
+            jsonArray.add(cacheObject);
+        }
+
+        jsonObject.put("maintenanceData",jsonArray);
+        return jsonObject;
+    }
+
+}
diff --git a/src/main/java/jenkins/plugins/git/maintenance/Task.java b/src/main/java/jenkins/plugins/git/maintenance/Task.java
new file mode 100644
index 0000000000..06168b59d9
--- /dev/null
+++ b/src/main/java/jenkins/plugins/git/maintenance/Task.java
@@ -0,0 +1,87 @@
+package jenkins.plugins.git.maintenance;
+
+/**
+ * POJO to store configuration for maintenance tasks.
+ *
+ * @author Hrushikesh Rao
+ */
+public class Task {
+
+    private TaskType task;
+    private String cronSyntax;
+    private boolean isConfigured;
+
+    /**
+     * Initialize a maintenance task object.
+     *
+     * @param task {@link TaskType}.
+     */
+    public Task(TaskType task){
+        // Can add default cron syntax recommended by git documentation
+        this.task = task;
+    }
+
+    /**
+     * A convenience constructor that copies the Task object.
+     *
+     * @param copyTask task object.
+     *
+     */
+    public Task(Task copyTask){
+        // Used for copying the task;
+        this(copyTask.getTaskType());
+        setCronSyntax(copyTask.getCronSyntax());
+        setIsTaskConfigured(copyTask.getIsTaskConfigured());
+    }
+
+    /**
+     * Gets the TaskType enum.
+     *
+     * @return TaskType {@link TaskType}.
+     */
+    public TaskType getTaskType(){
+        return this.task;
+    }
+
+    /**
+     * Gets the name of the maintenance task.
+     *
+     * @return maintenance task name.
+     */
+    public String getTaskName(){
+        return this.task.getTaskName();
+    }
+
+    /**
+     *
+     * @return cron syntax configured for a maintenance task.
+     */
+    public String getCronSyntax(){ return this.cronSyntax; }
+
+    /**
+     *  Toggle the state of execution of maintenance task.
+     *
+     * @param isConfigured if true, corresponding task is configured and executed using cron syntax.
+     */
+    public void setIsTaskConfigured(boolean isConfigured){
+        this.isConfigured = isConfigured;
+    }
+
+    /**
+     *
+     * @return A boolean to check maintenance task is configured by administrator.
+     */
+    public boolean getIsTaskConfigured(){
+        return this.isConfigured;
+    }
+
+    /**
+     * Configure the Cron Syntax
+     *
+     * @param cronSyntax cron syntax as String
+     *
+     */
+    public void setCronSyntax(String cronSyntax){
+        this.cronSyntax = cronSyntax;
+    }
+}
diff --git a/src/main/java/jenkins/plugins/git/maintenance/TaskExecutor.java b/src/main/java/jenkins/plugins/git/maintenance/TaskExecutor.java
new file mode 100644
index 0000000000..5124db6b1d
--- /dev/null
+++ b/src/main/java/jenkins/plugins/git/maintenance/TaskExecutor.java
@@ -0,0 +1,237 @@
+package jenkins.plugins.git.maintenance;
+
+import hudson.FilePath;
+import hudson.model.TaskListener;
+import hudson.plugins.git.GitTool;
+import hudson.plugins.git.util.GitUtils;
+import hudson.util.LogTaskListener;
+import jenkins.model.Jenkins;
+import jenkins.plugins.git.maintenance.Logs.CacheRecord;
+import jenkins.plugins.git.maintenance.Logs.XmlSerialize;
+import org.apache.commons.io.FileUtils;
+import org.jenkinsci.plugins.gitclient.CliGitAPIImpl;
+import org.jenkinsci.plugins.gitclient.Git;
+import org.jenkinsci.plugins.gitclient.GitClient;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.List;
+import java.util.concurrent.locks.Lock;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * TaskExecutor executes the maintenance tasks on all Caches on Jenkins controller. A lock is added to each cache before running maintenance on it.
+ * It is an independent thread. If a cache is already locked, it skips the maintenance task. {@link GitClient} manages the execution of maintenance.
+ *
+ * @author Hrushikesh Rao
+ */
+public class TaskExecutor implements Runnable {
+
+    /**
+     * Boolean to toggle the state of execution of thread.
+     */
+    private volatile boolean isThreadAlive;
+
+    /**
+     * Type of maintenance task being executed on caches.
+     */
+    Task maintenanceTask;
+
+    /**
+     * List of caches present on Jenkins controller.
+     */
+    private List<GitMaintenanceSCM.Cache> caches;
+
+    XmlSerialize xmlSerialize;
+
+    private static final Logger LOGGER = Logger.getLogger(TaskExecutor.class.getName());
+
+    /**
+     * Initializes the thread to execute a maintenance task.
+     *
+     * @param maintenanceTask Type of maintenance task required for execution.
+     */
+    public TaskExecutor(Task maintenanceTask){
+        this.maintenanceTask = new Task(maintenanceTask);
+        caches = getCaches();
+        isThreadAlive = true;
+        xmlSerialize = new XmlSerialize();
+        LOGGER.log(Level.FINE,"New Thread created to execute " + maintenanceTask.getTaskName());
+    }
+
+    /**
+     * Executes the maintenance task by iterating through the all caches on Jenkins controller.
+     */
+    @Override
+    public void run() {
+
+        LOGGER.log(Level.INFO,"Executing maintenance task " + maintenanceTask.getTaskName() + " on git caches.");
+        try {
+            for (GitMaintenanceSCM.Cache cache : caches) {
+                // For now adding lock to all kinds of maintenance tasks. Need to study on which task needs a lock and which doesn't.
+                Lock lock = cache.getLock();
+                File cacheFile = cache.getCacheFile();
+                executeMaintenanceTask(cacheFile,lock);
+            }
+
+            LOGGER.log(Level.INFO,maintenanceTask.getTaskName() + " has been executed successfully.");
+        }catch (InterruptedException e){
+            LOGGER.log(Level.WARNING,"Interrupted Exception. Msg: " + e.getMessage());
+        }
+
+    }
+
+    /**
+     * Executes maintenance task on a single cache. The cache is first locked and then undergoes git maintenance.
+     *
+     * @param cacheFile File of a single cache.
+     * @param lock Lock for a single cache.
+     * @throws InterruptedException When GitClient is interrupted during maintenance execution.
+     */
+    void executeMaintenanceTask(File cacheFile,Lock lock) throws InterruptedException{
+
+        TaskType taskType = maintenanceTask.getTaskType();
+        long executionDuration = 0;
+        boolean executionStatus = false;
+        GitClient gitClient;
+        // If lock is not available on the cache, skip maintenance on this cache.
+        if (isThreadAlive && lock.tryLock()) {
+
+            LOGGER.log(Level.FINE, "Cache " + cacheFile.getName() + " locked.");
+
+            try {
+                gitClient = getGitClient(cacheFile);
+                if (gitClient == null)
+                    throw new InterruptedException("Git Client couldn't be instantiated");
+
+                executionDuration -= System.currentTimeMillis();
+
+                executionStatus = executeGitMaintenance(gitClient,taskType);
+
+                executionDuration += System.currentTimeMillis();
+            } catch (InterruptedException e) {
+                LOGGER.log(Level.FINE, "Couldn't run " + taskType.getTaskName() + ".Msg: " + e.getMessage());
+            } finally {
+                lock.unlock();
+                LOGGER.log(Level.FINE, "Cache " + cacheFile.getName() + " unlocked.");
+            }
+
+        } else {
+            if(!isThreadAlive)
+                throw new InterruptedException("Maintenance thread has been interrupted. Terminating...");
+            else
+                LOGGER.log(Level.FINE,"Cache is already locked. Can't run maintenance on cache " + cacheFile.getName());
+        }
+
+        xmlSerialize.addMaintenanceRecord(createRecord(cacheFile,taskType,executionStatus,executionDuration)); // Stores the record in jenkins.
+    }
+
+    /**
+     * Executes git maintenance on single cache.{@link TaskType} defines the type of maintenance task.
+     *
+     * @param gitClient {@link GitClient} on a single cache.
+     * @param taskType Type of maintenance task.
+     * @return Boolean if maintenance has been executed or not.
+     * @throws InterruptedException When GitClient is interrupted during maintenance execution.
+     */
+    boolean executeGitMaintenance(GitClient gitClient,TaskType taskType) throws InterruptedException {
+        boolean isExecuted = false;
+        switch (taskType){
+            case GC:
+                isExecuted = gitClient.maintenance("gc");
+                break;
+            case COMMIT_GRAPH:
+                isExecuted = gitClient.maintenance("commit-graph");
+                break;
+            case PREFETCH:
+                isExecuted = gitClient.maintenance("prefetch");
+                break;
+            case INCREMENTAL_REPACK:
+                isExecuted = gitClient.maintenance("incremental-repack");
+                break;
+            case LOOSE_OBJECTS:
+                isExecuted = gitClient.maintenance("loose-objects");
+                break;
+            default:
+                LOGGER.log(Level.WARNING,"Invalid maintenance task.");
+                terminateThread();
+        }
+        return isExecuted;
+    }
+
+    /**
+     * Returns a list of caches present on Jenkins controller. See {@link GitMaintenanceSCM#getCaches()}
+     *
+     * @return List of caches on Jenkins controller.
+     */
+    List<GitMaintenanceSCM.Cache> getCaches(){
+        List<GitMaintenanceSCM.Cache> caches =  GitMaintenanceSCM.getCaches();
+        LOGGER.log(Level.FINE,"Fetched all caches present on Jenkins Controller.");
+        return caches;
+    }
+
+    /**
+     * Returns {@link GitClient} on a single cache.
+     *
+     * @param file File object of a single cache.
+     * @return GitClient on single cache.
+     */
+    GitClient getGitClient(File file){
+        try {
+            TaskListener listener = new LogTaskListener(LOGGER, Level.FINE);
+            final Jenkins jenkins = Jenkins.getInstanceOrNull();
+            GitTool gitTool = GitUtils.resolveGitTool(null, jenkins, null, listener);
+            if (gitTool == null) {
+                LOGGER.log(Level.WARNING, "No GitTool found while running " + maintenanceTask.getTaskName());
+                return null;
+            }
+
+            String gitExe = gitTool.getGitExe();
+            if (file != null) {
+                FilePath workspace = new FilePath(file);
+                Git git = Git.with(listener, null).in(workspace).using(gitExe);
+
+                GitClient gitClient = git.getClient();
+                if (gitClient instanceof CliGitAPIImpl)
+                    return gitClient;
+                LOGGER.log(Level.WARNING, "JGit requested, but does not execute maintenance tasks");
+            } else {
+                LOGGER.log(Level.WARNING, "Cli Git will not execute maintenance tasks due to null file arg");
+            }
+
+        }catch (InterruptedException | IOException e ){
+            LOGGER.log(Level.WARNING,"Git Client couldn't be initialized.");
+        }
+        return null;
+    }
+
+    /**
+     * Terminates this thread and stops further execution of maintenance tasks.
+     */
+    public void terminateThread(){
+        isThreadAlive = false;
+    }
+
+    /**
+     * Returns a Record ({@link CacheRecord}) which contains the result of maintenance data on a single cache.
+     *
+     * @param cacheFile File object of a single cache.
+     * @param taskType Type of maintenance task.
+     * @param executionStatus Whether maintenance task has been executed successfully on a cache.
+     * @param executionDuration Amount of time taken to execute maintenance task in milliseconds.
+     * @return {@link CacheRecord} of a single cache.
+     */
+    CacheRecord createRecord(File cacheFile, TaskType taskType,boolean executionStatus,long executionDuration){
+
+       CacheRecord cacheRecord = new CacheRecord(cacheFile.getName(),taskType.getTaskName());
+       long repoSizeInBytes = FileUtils.sizeOfDirectory(cacheFile);
+       cacheRecord.setRepoSize(repoSizeInBytes);
+       cacheRecord.setExecutionStatus(executionStatus);
+       if(!executionStatus)
+           cacheRecord.setExecutionDuration(-1);
+       else cacheRecord.setExecutionDuration(executionDuration);
+       cacheRecord.setTimeOfExecution(System.currentTimeMillis()/1000); // Store the unix timestamp
+       return cacheRecord;
+    }
+}
diff --git a/src/main/java/jenkins/plugins/git/maintenance/TaskScheduler.java b/src/main/java/jenkins/plugins/git/maintenance/TaskScheduler.java
new file mode 100644
index 0000000000..cf0999ee23
--- /dev/null
+++ b/src/main/java/jenkins/plugins/git/maintenance/TaskScheduler.java
@@ -0,0 +1,182 @@
+package jenkins.plugins.git.maintenance;
+
+import antlr.ANTLRException;
+import hudson.scheduler.CronTab;
+import hudson.scheduler.CronTabList;
+import hudson.scheduler.Hash;
+import jenkins.model.GlobalConfiguration;
+
+import java.util.Calendar;
+import java.util.Collections;
+import java.util.GregorianCalendar;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Random;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * TaskScheduler is responsible for scheduling maintenance tasks. It validates if a task is configured and verifies cron syntax before scheduling.
+ * TaskScheduler acts as a producer by adding the appropriate task into a maintenance queue.
+ *
+ * @author Hrushikesh Rao
+ */
+public class TaskScheduler {
+
+    private MaintenanceTaskConfiguration config;
+
+    /**
+     * Stores the order of execution of maintenance tasks.
+     */
+    private List<Task> maintenanceQueue;
+
+    /**
+     * {@link TaskExecutor} executes the maintenance tasks on all the caches.
+     */
+    private Thread taskExecutor;
+    private TaskExecutor taskExecutorRunnable;
+
+    private static final Logger LOGGER = Logger.getLogger(TaskScheduler.class.getName());
+    private static final Random random = new Random();
+
+    /**
+     * Loads the maintenance configuration configured by the administrator. Also initializes an empty maintenance queue.
+     */
+    public TaskScheduler(){
+       this.config = GlobalConfiguration.all().get(MaintenanceTaskConfiguration.class);
+       this.maintenanceQueue = new LinkedList<>();
+       LOGGER.log(Level.FINE,"TaskScheduler class Initialized.");
+    }
+
+    /**
+     * Schedules maintenance tasks on caches.
+     */
+    void scheduleTasks() {
+        if(config != null) {
+            if (!isGitMaintenanceTaskRunning(config)) {
+                // Logs ever 1 min. Need to check performance impact.
+                LOGGER.log(Level.FINER, "Maintenance Task execution not configured in UI.");
+                return;
+            }
+
+            List<Task> maintenanceTasks = config.getMaintenanceTasks();
+            addTasksToQueue(maintenanceTasks);
+            // Option of Using the same thread for executing more maintenance task, or create a new thread the next minute and execute the maintenance task.
+            createTaskExecutorThread();
+        }else{
+            LOGGER.log(Level.FINE,"Couldn't load Global git maintenance configuration. Internal Error.");
+        }
+
+    }
+
+    /**
+     * Checks for duplication of maintenance task in the queue.
+     *
+     * @param task type of maintenance task ({@link Task}).
+     * @return a boolean to see if a task is already present in maintenance queue.
+     */
+    boolean checkIsTaskInQueue(Task task){
+        boolean isTaskInQueue = maintenanceQueue.stream().anyMatch(queuedTask -> queuedTask.getTaskType().equals(task.getTaskType()));
+        if(isTaskInQueue){
+            LOGGER.log(Level.FINE,task.getTaskName() + " is already present in maintenance queue.");
+        }
+        return isTaskInQueue;
+    }
+
+    /**
+     *  A new Thread {@link TaskExecutor} is created which executes the maintenance task on caches.
+     */
+    void createTaskExecutorThread(){
+        // Create a new thread and execute the tasks present in the queue;
+        if(!maintenanceQueue.isEmpty() && (taskExecutor == null || !taskExecutor.isAlive())) {
+            Task currentTask = maintenanceQueue.remove(0);
+            taskExecutorRunnable = new TaskExecutor(currentTask);
+            taskExecutor = new Thread(taskExecutorRunnable, "maintenance-task-executor");
+            taskExecutor.start();
+            LOGGER.log(Level.INFO,"Thread [" + taskExecutor.getName() +"] created to execute " + currentTask.getTaskName() + " task.");
+        }
+    }
+
+    /**
+     * Iterates through all the maintenance tasks and adds the task to queue if valid.
+     *
+     * @param maintenanceTasks List of maintenance tasks {@link Task}
+     */
+    void addTasksToQueue(List<Task> maintenanceTasks){
+
+        boolean isTaskExecutable;
+        for(Task task : maintenanceTasks){
+            try {
+                if(!task.getIsTaskConfigured() || checkIsTaskInQueue(task))
+                    continue;
+
+                CronTabList cronTabList = getCronTabList(task.getCronSyntax());
+                isTaskExecutable = checkIsTaskExecutable(cronTabList);
+                if(isTaskExecutable){
+                    maintenanceQueue.add(task);
+                    LOGGER.log(Level.INFO,task.getTaskName() + " added to maintenance queue.");
+                }
+            }catch (ANTLRException e){
+                // Logged every minute. Need to check performance.
+                LOGGER.log(Level.WARNING,"Invalid cron syntax:[ "+ task.getTaskName() + " ]" + ",msg: " + e.getMessage());
+            }
+        }
+    }
+
+    /**
+     * Checks if global git maintenance is configured.
+     * @param config {@link MaintenanceTaskConfiguration}.
+     * @return Global git maintenance is configured or not.
+     */
+    boolean isGitMaintenanceTaskRunning(MaintenanceTaskConfiguration config){
+        return config.getIsGitMaintenanceRunning();
+    }
+
+    /**
+     * Returns CronTabList for a cronSyntax.
+     *
+     * @param cronSyntax cron syntax for maintenance task.
+     * @return {@link CronTabList}
+     * @throws ANTLRException
+     */
+    CronTabList getCronTabList(String cronSyntax) throws ANTLRException {
+        // Random number between 0 & 100000
+        String seed = String.valueOf((random.nextInt(100000)));
+        CronTab cronTab = new CronTab(cronSyntax.trim(), Hash.from(seed));
+        return new CronTabList(Collections.singletonList(cronTab));
+    }
+
+    /**
+     * Checks if the cron syntax matches the current time. Returns true if valid.
+     *
+     * @param cronTabList {@link CronTabList}
+     * @return maintenance task should be scheduled or not.
+     */
+    boolean checkIsTaskExecutable(CronTabList cronTabList){
+        boolean isTaskExecutable = false;
+
+        Calendar cal = new GregorianCalendar();
+        isTaskExecutable = cronTabList.check(cal);
+        // Further validation such as not schedule a task every minute etc. can be added here.
+
+        return isTaskExecutable;
+    }
+
+    /**
+     * Terminates the {@link TaskExecutor} thread to stop executing maintenance on caches. Also empties the maintenance queue.
+     */
+    void terminateMaintenanceTaskExecution(){
+        this.maintenanceQueue = new LinkedList<>();
+        if(taskExecutor != null && taskExecutor.isAlive())
+            taskExecutorRunnable.terminateThread();
+
+        LOGGER.log(Level.INFO,"Terminated Execution of maintenance tasks");
+    }
+
+    List<Task> getMaintenanceQueue(){
+        return maintenanceQueue;
+    }
+    Thread getTaskExecutor(){
+        return taskExecutor;
+    }
+}
diff --git a/src/main/java/jenkins/plugins/git/maintenance/TaskType.java b/src/main/java/jenkins/plugins/git/maintenance/TaskType.java
new file mode 100644
index 0000000000..1074a8f9ff
--- /dev/null
+++ b/src/main/java/jenkins/plugins/git/maintenance/TaskType.java
@@ -0,0 +1,39 @@
+package jenkins.plugins.git.maintenance;
+
+/**
+ * TaskType describes the type of maintenance task. There are 5 types of maintenance tasks. They are-
+ * <ul>
+ *     <li>Prefetch</li>
+ *     <li>Garbage Collection</li>
+ *     <li>Commit Graph</li>
+ *     <li>Loose Objects</li>
+ *     <li>Incremental Repack</li>
+ * </ul>
+ *
+ * @author Hrushikesh Rao
+ */
+public enum TaskType {
+        GC("Garbage Collection"),
+        PREFETCH("Prefetch"),
+        COMMIT_GRAPH("Commit Graph"),
+        LOOSE_OBJECTS("Loose Objects"),
+        INCREMENTAL_REPACK("Incremental Repack");
+
+        String taskName;
+
+        /**
+         *
+         * @param taskName Assign a name for maintenance task.
+         */
+        TaskType(String taskName){
+                this.taskName = taskName;
+        }
+
+        /**
+         *
+         * @return name of the maintenance task.
+         */
+        public String getTaskName(){
+                return this.taskName;
+        }
+}
diff --git a/src/main/resources/jenkins/plugins/git/maintenance/MaintenanceUI/help-commit-graph.html b/src/main/resources/jenkins/plugins/git/maintenance/MaintenanceUI/help-commit-graph.html
new file mode 100644
index 0000000000..50fe86c862
--- /dev/null
+++ b/src/main/resources/jenkins/plugins/git/maintenance/MaintenanceUI/help-commit-graph.html
@@ -0,0 +1,3 @@
+<div>
+    Help regarding commit graph
+</div>
\ No newline at end of file
diff --git a/src/main/resources/jenkins/plugins/git/maintenance/MaintenanceUI/help-gc.html b/src/main/resources/jenkins/plugins/git/maintenance/MaintenanceUI/help-gc.html
new file mode 100644
index 0000000000..b0ad57c725
--- /dev/null
+++ b/src/main/resources/jenkins/plugins/git/maintenance/MaintenanceUI/help-gc.html
@@ -0,0 +1,3 @@
+<div>
+    Help regarding gc
+</div>
diff --git a/src/main/resources/jenkins/plugins/git/maintenance/MaintenanceUI/help-incremental-repack.html b/src/main/resources/jenkins/plugins/git/maintenance/MaintenanceUI/help-incremental-repack.html
new file mode 100644
index 0000000000..f4feaf18a4
--- /dev/null
+++ b/src/main/resources/jenkins/plugins/git/maintenance/MaintenanceUI/help-incremental-repack.html
@@ -0,0 +1,3 @@
+<div>
+    Help regarding incremental repack
+</div>
\ No newline at end of file
diff --git a/src/main/resources/jenkins/plugins/git/maintenance/MaintenanceUI/help-loose-objects.html b/src/main/resources/jenkins/plugins/git/maintenance/MaintenanceUI/help-loose-objects.html
new file mode 100644
index 0000000000..71d2dc5714
--- /dev/null
+++ b/src/main/resources/jenkins/plugins/git/maintenance/MaintenanceUI/help-loose-objects.html
@@ -0,0 +1,3 @@
+<div>
+    Help regarding loose-objects
+</div>
\ No newline at end of file
diff --git a/src/main/resources/jenkins/plugins/git/maintenance/MaintenanceUI/help-prefetch.html b/src/main/resources/jenkins/plugins/git/maintenance/MaintenanceUI/help-prefetch.html
new file mode 100644
index 0000000000..1e18161577
--- /dev/null
+++ b/src/main/resources/jenkins/plugins/git/maintenance/MaintenanceUI/help-prefetch.html
@@ -0,0 +1,3 @@
+<div>
+    Help regarding prefetch
+</div>
\ No newline at end of file
diff --git a/src/main/resources/jenkins/plugins/git/maintenance/MaintenanceUI/index.jelly b/src/main/resources/jenkins/plugins/git/maintenance/MaintenanceUI/index.jelly
new file mode 100644
index 0000000000..601436029a
--- /dev/null
+++ b/src/main/resources/jenkins/plugins/git/maintenance/MaintenanceUI/index.jelly
@@ -0,0 +1,64 @@
+<?jelly escape-by-default='true'?>
+<j:jelly xmlns:j="jelly:core" xmlns:l="/lib/layout" xmlns:f="/lib/form" xmlns:i="jelly:fmt" xmlns:st="jelly:stapler"
+         xmlns:t="/lib/hudson">
+    <!--    <st:adjunct includes="io.jenkins.plugins.data-tables"/>-->
+    <l:layout norefresh="true" type="one-column" title="Git Plugin" permission="${app.ADMINISTER}">
+        <l:main-panel>
+            <div>
+                <h1>Maintenance Tasks</h1>
+                <p><b><u>Git Version</u>: </b>${it.getGitVersion()}</p>
+                <p style="color:red;">${it.updateGitVersionHelperText()}</p>
+                <p>Enter cron syntax to execute maintenance tasks periodically</p>
+                <f:form action="save" method="post" name="save">
+                <j:forEach var="task" items="${it.getMaintenanceTasks()}">
+                    <div name="${task.getTaskType()}">
+                        <f:entry title="${task.getTaskName()}" field="cronSyntax">
+                            <f:checkbox name="my.isApplied" checked="${task.getIsTaskConfigured()}"/>
+                            <f:textbox name="my.cronSyntax" default="${task.getCronSyntax()}" checkUrl="'checkCronSyntax?cronSyntax='+escape(this.value)" checkMethod="post"/>
+                        </f:entry>
+                    </div>
+                </j:forEach>
+                    <button type="submit" class="jenkins-button">Save</button>
+                </f:form>
+
+                <j:if test="${it.getIsGitMaintenanceRunning() == 'false'}">
+                    <f:form method="post" action="executeMaintenanceTask" class="jenkins-!-margin-top-2" name="execute-maintenance-task">
+                            <button type="submit" class="jenkins-button jenkins-button--primary">Execute</button>
+                    </f:form>
+                </j:if>
+                <j:if test="${it.getIsGitMaintenanceRunning() == 'true'}">
+                    <f:form method="post" action="terminateMaintenanceTask" class="jenkins-!-margin-top-2" name="terminate-maintenance-task">
+                            <button type="submit" class="jenkins-button jenkins-button--destructive">Terminate</button>
+                    </f:form>
+                </j:if>
+            </div>
+
+            <st:bind var="a" value="${it}"/>
+
+            <hr/>
+
+            <div>
+                <h1>Maintenance Records</h1>
+<!--            Importing Table from table.jelly file-->
+               <st:include page="table.jelly" it="${it}" optional="false" />
+            </div>
+            <script>
+
+                // To display notification after submitting data from form.
+                a.getNotification(function (t) {
+                    var notificationData = t.responseObject();
+                    if (notificationData['msg']) {
+                        if (notificationData.msg.length > 0) {
+                            var msg = notificationData['msg'];
+                            if (notificationData.type == "OK")
+                                notificationBar.show(msg, notificationBar.OK);
+                            else if (notificationData.type == "ERROR")
+                                notificationBar.show(msg, notificationBar.ERROR);
+                            a.setNotification("", "");
+                        }
+                    }
+                })
+            </script>
+        </l:main-panel>
+    </l:layout>
+</j:jelly>
diff --git a/src/main/resources/jenkins/plugins/git/maintenance/MaintenanceUI/table.jelly b/src/main/resources/jenkins/plugins/git/maintenance/MaintenanceUI/table.jelly
new file mode 100644
index 0000000000..c232f8c0dc
--- /dev/null
+++ b/src/main/resources/jenkins/plugins/git/maintenance/MaintenanceUI/table.jelly
@@ -0,0 +1,153 @@
+<?jelly escape-by-default='true'?>
+<j:jelly xmlns:j="jelly:core"  xmlns:st="jelly:stapler" xmlns:fa="/font-awesome">
+    <style>
+        .font-awesome-icon{
+            height:30px;
+            width: 30px;
+        }
+    </style>
+        <st:adjunct includes="io.jenkins.plugins.data-tables"/>
+
+                <div class="fluid-container">
+                    <div class="table-responsive">
+                        <table class="table table-hover table-striped display" id="fixed">
+                            <thead>
+                                <tr>
+                                    <th>#</th>
+                                    <th>${%Cache Name}</th>
+                                    <th>${%Cache Size} (MB)</th>
+                                    <th>${%Task}</th>
+                                    <th>${%Time}</th>
+                                    <th>${%Status}</th>
+                                    <th>${%Execution Time} (mmm:ss:SSS)</th>
+                                    <th>Expand</th>
+                                </tr>
+                            </thead>
+                            <tbody>
+                                <j:forEach var="record" items="${it.getMaintenanceRecords()}" varStatus="loop">
+                                    <tr>
+                                        <td>
+                                            ${loop.count}
+                                        </td>
+                                        <td>
+                                            ${record.getRepoName()}
+                                        </td>
+                                        <td>
+<!--                                            Converting Bytes to MB-->
+                                            ${record.getRepoSize()/1000000}
+                                        </td>
+                                        <td>
+                                            ${record.getMaintenanceType()}
+                                        </td>
+                                        <td>
+                                            ${record.getTimeOfExecution()}
+                                        </td>
+                                        <td>
+                                            <j:if test="${record.getExecutionStatus()}">
+                                                <fa:svg-icon name="check" class="font-awesome-icon" ></fa:svg-icon>
+                                            </j:if>
+                                            <j:if test="${!record.getExecutionStatus()}">
+                                                <fa:svg-icon name="xmark" class="font-awesome-icon" ></fa:svg-icon>
+                                            </j:if>
+                                        </td>
+                                        <td>
+                                            ${record.getExecutionDuration()}
+                                        </td>
+                                        <td class="expand">
+                                            Expand
+                                        </td>
+                                    </tr>
+                                </j:forEach>
+                            </tbody>
+
+                            <tfoot>
+                                <tr>
+                                    <th>#</th>
+                                    <th>${%Cache Name}</th>
+                                    <th>${%Cache Size} (MB)</th>
+                                    <th>${%Task}</th>
+                                    <th>${%Time}</th>
+                                    <th>${%Status}</th>
+                                    <th>${%Execution Time} (mmm:ss:SSS)</th>
+                                    <th>Expand</th>
+                                </tr>
+                            </tfoot>
+                        </table>
+                    </div>
+                </div>
+
+
+    <script>
+        function format(maintenanceRecords) {
+            let tableData = "";
+            let index = 1;
+            for(let record of maintenanceRecords){
+                row = '<tr>';
+                row+= '<td>' + index++ + '</td>>'
+
+                for(let key in record){
+                    row+= '<td>' + record[key] + '</td>'
+                }
+                row += '</tr>';
+                tableData += row;
+            }
+
+
+            return (
+                '<table cellpadding="5" cellspacing="10" border="0" style="padding-left:50px;" id="allCacheRecords">' +
+                '<thead><th>#</th><th>Task</th><th>Time</th><th>Status</th><th>Duration (ms)</th><th>RepoSize</th></thead>' +
+                        tableData +
+                '</table>'
+            );
+        }
+
+        jQuery(document).ready(function(){
+
+            var table = jQuery('#fixed').DataTable({
+                pagingType: 'numbers',// Page number button only,
+                columnDefs: [
+                { "type": "execution-time",targets:[6]}
+                ],
+            });
+
+            jQuery('#fixed').on('click','.expand',function(){
+                var tr = jQuery(this).closest('tr');
+                var row = table.row(tr);
+                if (row.child.isShown()) {
+                    // This row is already open - close it
+                    row.child.hide();
+                    tr.removeClass('shown');
+                } else {
+                    // Open this row
+                        a.getRecordsForSingleCache(row.data()[1],function (t){
+                        var allMaintenanceRecords = t.responseObject()['maintenanceData']; // fetches all records when clicking expand button.
+                        row.child(format(allMaintenanceRecords)).show();
+                        tr.addClass('shown');
+                     });
+                }
+            })
+
+        // Sorting execution time data in ascending order
+        jQuery().extend( jQuery().dataTable.ext.type.order, {
+        "execution-time-asc": function (val_1, val_2) {
+        // your sorting code here - or a call to a function
+            let time1 = Number.parseInt(val_1.split(":").join(""));
+            let time2 = Number.parseInt(val_2.split(":").join(""));
+            return time1 > time2 ? 1 : time1 === time2 ? 0 : -1;
+        }
+        } );
+
+        // Sorting execution time data in descending order
+        jQuery().extend( jQuery().dataTable.ext.type.order, {
+        "execution-time-desc": function (val_1, val_2) {
+        // your sorting code here - or a call to a function
+            let time1 = Number.parseInt(val_1.split(":").join(""));
+            let time2 = Number.parseInt(val_2.split(":").join(""));
+
+            return time1 > time2 ? -1 : time1 === time2 ? 0 : 1;
+        }
+        } );
+        });
+
+    </script>
+</j:jelly>
diff --git a/src/main/webapp/icons/git-maintenance.svg b/src/main/webapp/icons/git-maintenance.svg
new file mode 100644
index 0000000000..66ab7a3350
--- /dev/null
+++ b/src/main/webapp/icons/git-maintenance.svg
@@ -0,0 +1,51 @@
+<?xml version="1.0" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 20010904//EN"
+ "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd">
+<svg version="1.0" xmlns="http://www.w3.org/2000/svg"
+ width="1280.000000pt" height="822.000000pt" viewBox="0 0 1280.000000 822.000000"
+ preserveAspectRatio="xMidYMid meet">
+<metadata>
+Created by potrace 1.15, written by Peter Selinger 2001-2017
+</metadata>
+<g transform="translate(0.000000,822.000000) scale(0.100000,-0.100000)"
+fill="#000000" stroke="none">
+<path d="M12540 8146 c-69 -40 -966 -558 -1995 -1151 -1028 -593 -2735 -1577
+-3793 -2187 -1057 -610 -1927 -1106 -1933 -1103 -5 4 -53 -10 -106 -31 -107
+-41 -148 -52 -209 -58 -53 -5 -94 -27 -140 -73 -21 -20 -44 -38 -53 -40 -9 -1
+-38 -6 -66 -11 -60 -10 -87 -23 -113 -57 -27 -34 -47 -31 -112 16 -91 65 -232
+128 -358 161 -101 26 -140 31 -292 35 -116 4 -211 1 -280 -8 -58 -7 -119 -13
+-136 -14 -17 -1 -35 -4 -40 -7 -5 -3 -49 -14 -99 -23 -49 -10 -99 -21 -110
+-26 -11 -4 -56 -18 -100 -30 -123 -33 -430 -144 -625 -224 -235 -98 -411 -181
+-885 -421 -442 -224 -753 -373 -948 -454 -70 -29 -125 -55 -123 -57 7 -7 237
+47 340 81 58 18 106 32 106 30 0 -2 -19 -13 -42 -25 -109 -55 -339 -182 -335
+-185 7 -8 410 122 562 181 42 17 3 -6 -248 -145 -142 -78 -256 -144 -254 -146
+7 -7 362 121 499 180 59 25 45 12 -29 -29 -113 -62 -431 -275 -411 -275 8 0
+275 110 421 173 70 30 127 54 127 52 0 -2 -26 -18 -57 -36 -145 -82 -438 -278
+-429 -287 7 -6 270 96 466 180 102 43 192 82 200 85 18 6 -2 -7 -180 -117
+-147 -90 -413 -271 -407 -276 3 -4 278 110 427 176 137 61 160 71 160 66 0 -2
+-21 -16 -47 -31 -78 -45 -485 -317 -480 -321 7 -7 446 180 569 242 95 48 59
+22 -102 -74 -195 -116 -423 -263 -417 -269 7 -6 405 129 521 176 55 22 101 40
+102 38 1 -1 -63 -39 -144 -85 -266 -150 -417 -242 -399 -242 58 0 315 83 480
+155 55 25 102 43 104 42 1 -2 -53 -38 -120 -79 -127 -79 -337 -225 -372 -259
+-20 -19 -19 -19 35 -3 95 28 270 94 394 150 66 29 121 52 123 50 2 -2 -24 -20
+-57 -40 -132 -82 -427 -302 -417 -312 8 -8 209 76 387 162 96 47 171 81 165
+76 -5 -5 -80 -60 -165 -124 -85 -64 -191 -150 -235 -192 l-80 -75 65 25 c74
+30 329 153 440 213 41 22 62 31 46 18 -16 -12 -79 -60 -139 -107 -113 -87
+-300 -259 -318 -291 -11 -22 212 101 541 300 38 23 14 0 -85 -79 -90 -72 -395
+-338 -395 -345 0 -10 399 192 445 225 22 15 149 80 129 65 -11 -8 -90 -66
+-175 -128 -210 -152 -338 -251 -333 -256 2 -3 135 61 294 141 160 80 290 144
+290 143 0 -1 -19 -15 -42 -30 -64 -42 -466 -344 -473 -355 -6 -10 21 1 176 73
+73 34 351 179 434 227 58 34 49 27 -157 -128 -195 -146 -390 -303 -384 -309
+10 -11 366 165 496 245 49 31 2 -7 -164 -133 -236 -178 -275 -209 -271 -213 8
+-8 293 133 450 223 63 35 46 18 -78 -79 -108 -85 -307 -255 -307 -262 0 -3 10
+0 21 7 21 11 417 248 474 284 45 28 17 2 -120 -113 -66 -55 -165 -144 -220
+-197 -95 -92 -97 -95 -50 -69 28 15 115 69 195 119 l145 90 -164 -162 c-90
+-90 -162 -166 -158 -169 3 -3 43 23 89 58 130 101 331 241 608 423 666 439
+848 562 1015 687 254 191 601 485 675 573 14 16 51 56 83 89 31 33 57 61 57
+62 0 2 35 50 78 107 156 207 253 406 299 611 8 39 18 143 22 230 l6 159 50 12
+c34 9 58 23 78 47 16 18 39 45 51 59 14 15 42 31 72 38 59 15 106 45 129 83
+22 39 55 70 155 151 47 38 84 74 83 81 -1 6 294 181 655 389 361 208 2126
+1225 3922 2261 2770 1597 3266 1887 3275 1910 8 22 4 37 -19 79 -33 61 -60 87
+-90 87 -11 -1 -77 -34 -146 -74z"/>
+</g>
+</svg>
diff --git a/src/spotbugs/excludesFilter.xml b/src/spotbugs/excludesFilter.xml
index bf1e7ef977..1a34e42287 100644
--- a/src/spotbugs/excludesFilter.xml
+++ b/src/spotbugs/excludesFilter.xml
@@ -14,6 +14,8 @@
     <Or>
       <Class name="hudson.plugins.git.GitChangeSetList" />
       <Class name="hudson.plugins.git.GitSCM" />
+      <Class name="jenkins.plugins.git.maintenance.MaintenanceTaskConfiguration" />
+      <Class name="jenkins.plugins.git.maintenance.TaskExecutor" />
     </Or>
   </Match>
   <Match>
diff --git a/src/test/java/hudson/plugins/git/extensions/impl/CloneOptionHonorRefSpecTest.java b/src/test/java/hudson/plugins/git/extensions/impl/CloneOptionHonorRefSpecTest.java
index f76050fe35..4e05f7222b 100644
--- a/src/test/java/hudson/plugins/git/extensions/impl/CloneOptionHonorRefSpecTest.java
+++ b/src/test/java/hudson/plugins/git/extensions/impl/CloneOptionHonorRefSpecTest.java
@@ -105,7 +105,6 @@ public void testRefSpecWithExpandedVariables() throws Exception {
         if (refSpecExpectedValue == null || refSpecExpectedValue.isEmpty()) {
             /* Test does not support an empty or null expected value.
                Skip the test if the expected value is empty or null */
-            System.out.println("*** testRefSpecWithExpandedVariables empty expected value for '" + refSpecName + "' ***");
             return;
         }
         // Create initial commit
diff --git a/src/test/java/hudson/plugins/git/util/GitUtilsTest.java b/src/test/java/hudson/plugins/git/util/GitUtilsTest.java
index 5e793eeb13..d2c6cbbfce 100644
--- a/src/test/java/hudson/plugins/git/util/GitUtilsTest.java
+++ b/src/test/java/hudson/plugins/git/util/GitUtilsTest.java
@@ -98,7 +98,7 @@ public class GitUtilsTest {
     private GitUtils gitUtils;
     private static GitClient gitClient;
 
-    private static final Random RANDOM = new Random();
+    private static final Random random = new Random();
 
     @BeforeClass
     public static void createSampleOriginRepo() throws Exception {
@@ -121,14 +121,14 @@ public static void createSampleOriginRepo() throws Exception {
         priorBranchSpecList.add(new BranchSpec(OLDER_BRANCH_NAME));
 
         originRepo.git("checkout", "master");
-        originRepo.write(fileName, "This is the " + HEAD_TAG_NAME_0 + " README file " + RANDOM.nextInt());
+        originRepo.write(fileName, "This is the " + HEAD_TAG_NAME_0 + " README file " + random.nextInt());
         originRepo.git("add", fileName);
         originRepo.git("commit", "-m", "Adding " + fileName + " tagged " + HEAD_TAG_NAME_0, fileName);
         originRepo.git("tag", HEAD_TAG_NAME_0);
         headTag0Id = ObjectId.fromString(originRepo.head());
         headTag0Revision = new Revision(headTag0Id);
 
-        originRepo.write(fileName, "This is the README file " + RANDOM.nextInt());
+        originRepo.write(fileName, "This is the README file " + random.nextInt());
         originRepo.git("add", fileName);
         originRepo.git("commit", "-m", "Adding " + fileName, fileName);
         originRepo.git("tag", HEAD_TAG_NAME_1);
diff --git a/src/test/java/jenkins/plugins/git/maintenance/GitMaintenanceSCMTest.java b/src/test/java/jenkins/plugins/git/maintenance/GitMaintenanceSCMTest.java
new file mode 100644
index 0000000000..bec193df3e
--- /dev/null
+++ b/src/test/java/jenkins/plugins/git/maintenance/GitMaintenanceSCMTest.java
@@ -0,0 +1,74 @@
+package jenkins.plugins.git.maintenance;
+
+import hudson.plugins.git.AbstractGitRepository;
+import hudson.plugins.git.AbstractGitTestCase;
+import hudson.plugins.git.BranchSpec;
+import hudson.plugins.git.GitSCM;
+import hudson.plugins.git.extensions.GitSCMExtension;
+import jenkins.model.Jenkins;
+import jenkins.plugins.git.AbstractGitSCMSource;
+import jenkins.plugins.git.AbstractGitSCMSourceTest;
+import jenkins.plugins.git.GitSampleRepoRule;
+import jenkins.scm.api.SCMFileSystem;
+import org.apache.commons.io.FileUtils;
+import org.junit.*;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.rules.TemporaryFolder;
+import org.jvnet.hudson.test.JenkinsRule;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
+import org.mockito.configuration.IMockitoConfiguration;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.RandomAccessFile;
+import java.util.*;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+import java.util.logging.Level;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.*;
+
+public class GitMaintenanceSCMTest {
+
+    @Rule
+    public JenkinsRule rule = new JenkinsRule();
+
+
+    @Test
+    public void testGetCaches() throws Exception{
+
+        // Cannot test this due to static methods not public,
+        // AbstractGitSCmSource is in different package
+        List<GitMaintenanceSCM.Cache>  caches = new ArrayList<>();
+        caches.add(new GitMaintenanceSCM.Cache(new File("test.txt"),new ReentrantLock()));
+
+
+        mockStatic(GitMaintenanceSCM.class)
+                .when(()->GitMaintenanceSCM.getCaches())
+                .thenReturn(caches);
+
+        assertEquals(caches.size(),GitMaintenanceSCM.getCaches().size());
+
+    }
+
+    @Test
+    public void testGetCacheFile(){
+        File file = Jenkins.getInstanceOrNull().getRootDir();
+        Lock lock = new ReentrantLock();
+        GitMaintenanceSCM.Cache cache = new GitMaintenanceSCM.Cache(file,lock);
+        assertEquals(file.getAbsolutePath(),cache.getCacheFile().getAbsolutePath());
+    }
+
+    @Test
+    public void testGetLock(){
+        File file = Jenkins.getInstanceOrNull().getRootDir();
+        Lock lock = new ReentrantLock();
+        GitMaintenanceSCM.Cache cache = new GitMaintenanceSCM.Cache(file,lock);
+        assertNotNull(cache.getLock());
+    }
+}
diff --git a/src/test/java/jenkins/plugins/git/maintenance/Logs/CacheRecordTest.java b/src/test/java/jenkins/plugins/git/maintenance/Logs/CacheRecordTest.java
new file mode 100644
index 0000000000..0fd27320d9
--- /dev/null
+++ b/src/test/java/jenkins/plugins/git/maintenance/Logs/CacheRecordTest.java
@@ -0,0 +1,149 @@
+package jenkins.plugins.git.maintenance.Logs;
+
+import io.jenkins.cli.shaded.org.apache.commons.lang.time.DurationFormatUtils;
+import jenkins.plugins.git.maintenance.TaskType;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.Assert.*;
+
+public class CacheRecordTest {
+
+    CacheRecord record;
+
+    @Before
+    public void setUp() throws Exception {
+        record = new CacheRecord("git-plugin", TaskType.GC.getTaskName());
+    }
+
+    @Test
+    public void testGetRepoName(){
+        assertEquals("git-plugin",record.getRepoName());
+    }
+
+    @Test
+    public void testSetRepoSize(){
+        record.setRepoSize(12343);
+        assertEquals(12343,record.getRepoSize());
+    }
+
+    @Test
+    public void testSetMaintenanceType(){
+        assertEquals(record.getMaintenanceType(),TaskType.GC.getTaskName());
+
+        record.setMaintenanceType(TaskType.PREFETCH.getTaskName());
+        assertEquals(TaskType.PREFETCH.getTaskName(),record.getMaintenanceType());
+    }
+
+    @Test
+    public void testSetTimeOfExecution(){
+        long timeOfExecution = 1661552520;
+        record.setTimeOfExecution(timeOfExecution);
+
+        Date date = new Date(timeOfExecution * 1000L);
+        SimpleDateFormat sdf = new SimpleDateFormat("dd-MM-yyyy HH:mm");
+        assertEquals(sdf.format(date),record.getTimeOfExecution());
+    }
+
+    @Test
+    public void testSetExecutionStatus(){
+        record.setExecutionStatus(false);
+        assertFalse(record.getExecutionStatus());
+
+        record.setExecutionStatus(true);
+        assertTrue(record.getExecutionStatus());
+    }
+
+    @Test
+    public void testSetExecutionDuration(){
+        long duration = System.currentTimeMillis();
+        record.setExecutionDuration(duration);
+        assertEquals(DurationFormatUtils.formatDuration(duration,"mmm:ss:SSS"),record.getExecutionDuration());
+    }
+
+    @Test
+    public void testInsertMaintenanceData(){
+        // Can add other metadata to these caches.
+        CacheRecord gcCacheRecord = new CacheRecord("git-plugin",TaskType.GC.getTaskName());
+        CacheRecord prefetchRecord = new CacheRecord("git-plugin",TaskType.PREFETCH.getTaskName());
+        CacheRecord commitGraphRecord = new CacheRecord("git-plugin",TaskType.COMMIT_GRAPH.getTaskName());
+        CacheRecord incrementalRepackRecord = new CacheRecord("git-plugin",TaskType.INCREMENTAL_REPACK.getTaskName());
+        CacheRecord looseObjectsRecord = new CacheRecord("git-plugin",TaskType.LOOSE_OBJECTS.getTaskName());
+
+        record.insertMaintenanceData(gcCacheRecord);
+        record.insertMaintenanceData(prefetchRecord);
+        record.insertMaintenanceData(commitGraphRecord);
+        record.insertMaintenanceData(incrementalRepackRecord);
+        record.insertMaintenanceData(looseObjectsRecord);
+
+        for(Map.Entry<String, List<CacheRecord>> entry : record.maintenanceData.entrySet()){
+            assertEquals(1,entry.getValue().size());
+        }
+    }
+
+    @Test
+    public void getAllMaintenanceRecordsForSingleCache(){
+        CacheRecord gcCacheRecord = new CacheRecord("git-plugin",TaskType.GC.getTaskName());
+        CacheRecord prefetchRecord = new CacheRecord("git-plugin",TaskType.PREFETCH.getTaskName());
+        CacheRecord commitGraphRecord = new CacheRecord("git-plugin",TaskType.COMMIT_GRAPH.getTaskName());
+        CacheRecord incrementalRepackRecord = new CacheRecord("git-plugin",TaskType.INCREMENTAL_REPACK.getTaskName());
+        CacheRecord looseObjectsRecord = new CacheRecord("git-plugin",TaskType.LOOSE_OBJECTS.getTaskName());
+
+        // set the TimeofExecution for each cache
+        gcCacheRecord.setTimeOfExecution(1661552520);
+        prefetchRecord.setTimeOfExecution(1661553520);
+        commitGraphRecord.setTimeOfExecution(1661552120);
+        incrementalRepackRecord.setTimeOfExecution(1661572520);
+        looseObjectsRecord.setTimeOfExecution(1661512520);
+
+        record.insertMaintenanceData(gcCacheRecord);
+        record.insertMaintenanceData(prefetchRecord);
+        record.insertMaintenanceData(commitGraphRecord);
+        record.insertMaintenanceData(incrementalRepackRecord);
+        record.insertMaintenanceData(looseObjectsRecord);
+
+        // checking if the data received is in sorted manner or not.
+        boolean isSorted = true;
+
+        List<CacheRecord> cacheRecords = record.getAllMaintenanceRecordsForSingleCache();
+
+        for(int i=1;i<cacheRecords.size();i++){
+            if(cacheRecords.get(i).timeOfExecution > cacheRecords.get(i-1).timeOfExecution) {
+                isSorted = false;
+                break;
+            }
+        }
+
+        assertTrue(isSorted);
+    }
+
+    @Test
+    public void copyCacheRecord(){
+        long duration = System.currentTimeMillis();
+        long timeOfExecution = 1661552520;
+
+        record.setExecutionDuration(duration);
+        record.setExecutionStatus(true);
+        record.setTimeOfExecution(timeOfExecution);
+        record.setRepoSize(12343);
+        CacheRecord copyCacheRecord = new CacheRecord(record);
+
+        assertEquals(DurationFormatUtils.formatDuration(duration,"mmm:ss:SSS"),copyCacheRecord.getExecutionDuration());
+        assertTrue(record.getExecutionStatus());
+        assertEquals(TaskType.GC.getTaskName(),copyCacheRecord.getMaintenanceType());
+        assertEquals(12343,copyCacheRecord.getRepoSize());
+
+        Date date = new Date(timeOfExecution * 1000L);
+        SimpleDateFormat sdf = new SimpleDateFormat("dd-MM-yyyy HH:mm");
+        assertEquals(sdf.format(date),copyCacheRecord.getTimeOfExecution());
+    }
+
+
+
+}
diff --git a/src/test/java/jenkins/plugins/git/maintenance/Logs/RecordListTest.java b/src/test/java/jenkins/plugins/git/maintenance/Logs/RecordListTest.java
new file mode 100644
index 0000000000..906f7205b6
--- /dev/null
+++ b/src/test/java/jenkins/plugins/git/maintenance/Logs/RecordListTest.java
@@ -0,0 +1,110 @@
+package jenkins.plugins.git.maintenance.Logs;
+
+import jenkins.plugins.git.maintenance.TaskType;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.junit.Assert.*;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+public class RecordListTest {
+
+    RecordList recordList;
+
+    String cacheName = "git-plugin";
+    @Before
+    public void setUp() throws Exception {
+       recordList = new RecordList();
+    }
+
+    @Test
+    public void testGetAllMaintenanceRecords() {
+       assertThat(recordList.getMaintenanceRecords(),instanceOf(List.class));
+    }
+
+    @Test
+    public void testAddRecord() {
+        // Testing when adding the first cache record
+        CacheRecord record = new CacheRecord(cacheName, TaskType.GC.getTaskName());
+        record.setExecutionStatus(true);
+        recordList.addRecord(record);
+        assertEquals(1,recordList.getMaintenanceRecords().size());
+        assertTrue(recordList.getCacheSet().contains(cacheName));
+
+        // Testing the head of the List.
+        CacheRecord headRecord = recordList.getMaintenanceRecords().get(0);
+        assertEquals(TaskType.GC.getTaskName(),headRecord.getMaintenanceType());
+        assertEquals(cacheName,headRecord.getRepoName());
+        assertTrue(headRecord.getExecutionStatus());
+
+
+        // Testing when adding more records for same cache
+        CacheRecord gcCacheRecord = new CacheRecord(cacheName,TaskType.GC.getTaskName());
+        CacheRecord prefetchRecord = new CacheRecord(cacheName,TaskType.PREFETCH.getTaskName());
+        CacheRecord commitGraphRecord = new CacheRecord(cacheName,TaskType.COMMIT_GRAPH.getTaskName());
+        CacheRecord incrementalRepackRecord = new CacheRecord(cacheName,TaskType.INCREMENTAL_REPACK.getTaskName());
+        CacheRecord looseObjectsRecord = new CacheRecord(cacheName,TaskType.LOOSE_OBJECTS.getTaskName());
+        looseObjectsRecord.setExecutionStatus(false);
+
+        recordList.addRecord(gcCacheRecord);
+        recordList.addRecord(prefetchRecord);
+        recordList.addRecord(commitGraphRecord);
+        recordList.addRecord(incrementalRepackRecord);
+        recordList.addRecord(looseObjectsRecord);
+
+        assertEquals(1,recordList.getMaintenanceRecords().size());
+        assertTrue(recordList.getCacheSet().contains(cacheName));
+
+        // Here the head of the List Cache data will be updated with the latest maintenance data.
+        headRecord = recordList.getMaintenanceRecords().get(0);
+        assertEquals(cacheName,headRecord.getRepoName());
+        assertEquals(TaskType.LOOSE_OBJECTS.getTaskName(),headRecord.getMaintenanceType());
+        assertFalse(headRecord.getExecutionStatus());
+    }
+
+    @Test
+    public void testGetAllMaintenanceRecordsForSingleCache(){
+        // Adding record for new Cache
+        CacheRecord record = new CacheRecord(cacheName, TaskType.GC.getTaskName());
+        record.setTimeOfExecution(1661593520);
+        recordList.addRecord(record);
+
+        CacheRecord gcCacheRecord = new CacheRecord(cacheName,TaskType.GC.getTaskName());
+        CacheRecord prefetchRecord = new CacheRecord(cacheName,TaskType.PREFETCH.getTaskName());
+        CacheRecord commitGraphRecord = new CacheRecord(cacheName,TaskType.COMMIT_GRAPH.getTaskName());
+        CacheRecord incrementalRepackRecord = new CacheRecord(cacheName,TaskType.INCREMENTAL_REPACK.getTaskName());
+        CacheRecord looseObjectsRecord = new CacheRecord(cacheName,TaskType.LOOSE_OBJECTS.getTaskName()); // This is the latest cache record
+
+        // set the TimeofExecution for each cache
+        gcCacheRecord.setTimeOfExecution(1661552520);
+        prefetchRecord.setTimeOfExecution(1661553520);
+        commitGraphRecord.setTimeOfExecution(1661552120);
+        incrementalRepackRecord.setTimeOfExecution(1661572520);
+        looseObjectsRecord.setTimeOfExecution(1661512520);
+
+        recordList.addRecord(gcCacheRecord);
+        recordList.addRecord(prefetchRecord);
+        recordList.addRecord(commitGraphRecord);
+        recordList.addRecord(incrementalRepackRecord);
+        recordList.addRecord(looseObjectsRecord);
+
+        List<CacheRecord> allMaintenanceRecordsForSingleCache = recordList.getAllMaintenanceRecordsForSingleCache(cacheName);
+
+        assertEquals(6,allMaintenanceRecordsForSingleCache.size());
+
+        boolean isSorted = true;
+
+        for(int i=1;i<allMaintenanceRecordsForSingleCache.size();i++){
+            if(allMaintenanceRecordsForSingleCache.get(i).timeOfExecution > allMaintenanceRecordsForSingleCache.get(i-1).timeOfExecution){
+                isSorted = false;
+                break;
+            }
+        }
+
+        assertTrue(isSorted);
+    }
+
+}
diff --git a/src/test/java/jenkins/plugins/git/maintenance/MaintenanceTaskConfigurationTest.java b/src/test/java/jenkins/plugins/git/maintenance/MaintenanceTaskConfigurationTest.java
new file mode 100644
index 0000000000..93c455ab8b
--- /dev/null
+++ b/src/test/java/jenkins/plugins/git/maintenance/MaintenanceTaskConfigurationTest.java
@@ -0,0 +1,99 @@
+package jenkins.plugins.git.maintenance;
+
+import antlr.ANTLRException;
+import org.junit.ClassRule;
+import org.junit.Test;
+import org.jvnet.hudson.test.JenkinsRule;
+
+import java.util.List;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.both;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.number.OrderingComparison.greaterThan;
+import static org.hamcrest.number.OrderingComparison.lessThan;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+public class MaintenanceTaskConfigurationTest {
+
+    @ClassRule
+    public static JenkinsRule j = new JenkinsRule();
+    private final MaintenanceTaskConfiguration config = new MaintenanceTaskConfiguration();
+
+    @Test
+    public void setCronSyntax(){
+        String cronSyntax = "* * * 1 *";
+        for(TaskType taskType : TaskType.values()){
+            config.setCronSyntax(taskType,cronSyntax);
+        }
+
+        for(TaskType taskType : TaskType.values()){
+            List<Task> maintenanceTasks = config.getMaintenanceTasks();
+            for(Task task : maintenanceTasks){
+                if(task.getTaskType().equals(taskType)){
+                    assertThat(task.getCronSyntax(), is(cronSyntax));
+                    break;
+                }
+            }
+        }
+    }
+
+    @Test
+    public void setIsMaintenanceTaskConfigured(){
+        boolean isMaintenanceTaskConfigured = true;
+
+        for(TaskType taskType : TaskType.values()){
+            config.setIsTaskConfigured(taskType,isMaintenanceTaskConfigured);
+        }
+
+        for(TaskType taskType : TaskType.values()){
+            List<Task> maintenanceTasks = config.getMaintenanceTasks();
+            for(Task task : maintenanceTasks){
+                if(task.getTaskType().equals(taskType)){
+                    assertThat(task.getIsTaskConfigured(), is(isMaintenanceTaskConfigured));
+                    break;
+                }
+            }
+        }
+    }
+
+    @Test
+    public void setIsMaintenanceTaskRunning(){
+        // Default status
+        assertFalse(config.getIsGitMaintenanceRunning());
+
+        config.setIsGitMaintenanceRunning(true);
+        assertTrue(config.getIsGitMaintenanceRunning());
+        // When status is set to true
+        // Maintenance needs to be running
+        // assertTrue(config.getIsGitMaintenanceRunning());
+    }
+
+    @Test
+    public void checkValidCronSyntax() throws ANTLRException {
+
+        MaintenanceTaskConfiguration.checkSanity("* * * * *");
+        MaintenanceTaskConfiguration.checkSanity("1 * * * * ");
+        MaintenanceTaskConfiguration.checkSanity("H H(8-15)/2 * * 1-5");
+        MaintenanceTaskConfiguration.checkSanity("H H 1,15 1-11 *");
+    }
+
+    @Test(expected = ANTLRException.class)
+    public void checkInvalidCronSyntax() throws ANTLRException{
+        MaintenanceTaskConfiguration.checkSanity("");
+        MaintenanceTaskConfiguration.checkSanity("*****");
+        MaintenanceTaskConfiguration.checkSanity("a * * 1 *");
+    }
+
+    @Test
+    public void testGetGitVersion(){
+        List<Integer> gitVersion = MaintenanceTaskConfiguration.getGitVersion();
+        assertThat("Version list size error", gitVersion.size(), is(greaterThan(1)));
+        assertThat("Major version out of range", gitVersion.get(0), is(both(greaterThan(0)).and(lessThan(99))));
+        assertThat("Minor version out of range", gitVersion.get(1), is(both(greaterThan(-1)).and(lessThan(99))));
+        if (gitVersion.size() > 2) {
+            assertThat("Patch version out of range", gitVersion.get(2), is(both(greaterThan(-1)).and(lessThan(99))));
+        }
+    }
+}
diff --git a/src/test/java/jenkins/plugins/git/maintenance/ParameterizedCronSyntaxTest.java b/src/test/java/jenkins/plugins/git/maintenance/ParameterizedCronSyntaxTest.java
new file mode 100644
index 0000000000..78d4455ff6
--- /dev/null
+++ b/src/test/java/jenkins/plugins/git/maintenance/ParameterizedCronSyntaxTest.java
@@ -0,0 +1,66 @@
+package jenkins.plugins.git.maintenance;
+
+import antlr.ANTLRException;
+import org.junit.ClassRule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.jvnet.hudson.test.JenkinsRule;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+@RunWith(Parameterized.class)
+public class ParameterizedCronSyntaxTest {
+
+    @ClassRule
+    public static JenkinsRule j = new JenkinsRule();
+    String cronSyntax;
+    boolean isValid;
+
+    TaskScheduler taskScheduler;
+
+    public ParameterizedCronSyntaxTest(String cronSyntax,boolean isValid){
+        this.cronSyntax = cronSyntax;
+        this.isValid = isValid;
+        taskScheduler = new TaskScheduler();
+
+    }
+
+    @Parameterized.Parameters(name = "{0}")
+    public static Collection permuteCronSyntax(){
+       List<Object[]> crons = new ArrayList<>();
+       // valid cron syntax
+       crons.add(new Object[]{"H * * * *",true});
+       crons.add(new Object[]{"* * * * *", true});
+       crons.add(new Object[]{"@hourly",true});
+       crons.add(new Object[]{"@weekly",true});
+       crons.add(new Object[]{"@daily",true});
+       crons.add(new Object[]{"H H 1,15 1-11 *",true});
+
+       // invalid cron syntax;
+        crons.add(new Object[]{"",false});
+        crons.add(new Object[]{"**", false});
+        crons.add(new Object[]{"60 1 1 1 1",false});
+        crons.add(new Object[]{"1 1 1 1 9",false});
+        crons.add(new Object[]{"1 24 32 11 5",false});
+        crons.add(new Object[]{"",false});
+        return crons;
+    }
+
+    @Test
+    public void testCorrectAndIncorrectSyntaxInput(){
+        try {
+            assertNotNull(taskScheduler.getCronTabList(cronSyntax));
+            assertTrue(isValid);
+        }catch(ANTLRException e){
+            assertFalse(isValid);
+        }
+    }
+
+}
diff --git a/src/test/java/jenkins/plugins/git/maintenance/TaskExecutorTest.java b/src/test/java/jenkins/plugins/git/maintenance/TaskExecutorTest.java
new file mode 100644
index 0000000000..249dddf541
--- /dev/null
+++ b/src/test/java/jenkins/plugins/git/maintenance/TaskExecutorTest.java
@@ -0,0 +1,161 @@
+package jenkins.plugins.git.maintenance;
+
+import hudson.Launcher;
+import hudson.model.TaskListener;
+import hudson.plugins.git.*;
+import hudson.util.StreamTaskListener;
+import jenkins.model.GlobalConfiguration;
+import jenkins.plugins.git.GitSampleRepoRule;
+import jenkins.scm.api.SCMFileSystem;
+import org.jenkinsci.plugins.gitclient.GitClient;
+import org.junit.*;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.jvnet.hudson.test.JenkinsRule;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+import java.nio.charset.StandardCharsets;
+import java.util.*;
+import java.util.concurrent.locks.ReentrantLock;
+import java.util.logging.Level;
+import java.util.stream.Collectors;
+
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+@RunWith(Parameterized.class)
+public class TaskExecutorTest extends AbstractGitRepository {
+
+    @ClassRule
+    public static JenkinsRule rule = new JenkinsRule();
+
+    private Task gitTask;
+
+
+    public TaskExecutorTest(TaskType taskType){
+            this.gitTask = new Task(taskType);
+            this.gitTask.setCronSyntax("* * * * *");
+            this.gitTask.setIsTaskConfigured(true);
+    }
+
+    @Parameterized.Parameters(name = "{0}")
+    public static Collection permuteMaintenanceTasks(){
+
+        List<Object[]> maintenanceTasks = new ArrayList<>();
+
+        maintenanceTasks.add(new Object[]{TaskType.PREFETCH});
+        maintenanceTasks.add(new Object[]{TaskType.GC});
+        maintenanceTasks.add(new Object[]{TaskType.LOOSE_OBJECTS});
+        maintenanceTasks.add(new Object[]{TaskType.INCREMENTAL_REPACK});
+        maintenanceTasks.add(new Object[]{TaskType.COMMIT_GRAPH});
+        return maintenanceTasks;
+    }
+
+    @Test
+    public void testGitClient(){
+       // Get directory of a single cache.
+        TaskExecutor taskExecutor = new TestTaskExecutorHelper(gitTask,testGitDir);
+        assertTrue(taskExecutor.getCaches().size() > 0);
+        GitMaintenanceSCM.Cache cache = taskExecutor.getCaches().get(0);
+        File cacheFile = cache.getCacheFile();
+        assertNotNull(taskExecutor.getGitClient(cacheFile));
+        assertThat(taskExecutor.getGitClient(cacheFile),instanceOf(GitClient.class));
+    }
+
+    @Test
+    public void testNullFileInGetGitClient() {
+        GitClient client = new TestTaskExecutorHelper(gitTask,null).getGitClient(null);
+        assertNull(client);
+    }
+
+    @Test
+    public void testGetCaches(){
+        TaskExecutor taskExecutor = new TestTaskExecutorHelper(gitTask,testGitDir);
+        assertNotNull(taskExecutor.getCaches());
+    }
+
+    @Test
+    public void testExecuteGitMaintenance() throws Exception {
+
+        // This will create a pack file, incremental repack will then start to work.
+        repo.git("repack");
+
+        TaskExecutor taskExecutor = new TestTaskExecutorHelper(gitTask,testGitDir);
+        GitMaintenanceSCM.Cache cache = taskExecutor.getCaches().get(0);
+        File cacheFile = cache.getCacheFile();
+        GitClient client = taskExecutor.getGitClient(cacheFile);
+        boolean isExecuted = taskExecutor.executeGitMaintenance(client,gitTask.getTaskType());
+
+        // based on the underlying git version it will work.
+        // If git version < 2.30, tests may fail.
+        assertThat(isExecuted,is(true));
+    }
+
+    @Test
+    public void testRunnable() throws Exception {
+
+        // This will create a pack file, incremental repack will then start to work.
+        repo.git("repack");
+
+        MaintenanceTaskConfiguration config = GlobalConfiguration.all().get(MaintenanceTaskConfiguration.class);
+        config.setIsGitMaintenanceRunning(true);
+        config.setCronSyntax(gitTask.getTaskType(),"* * * * *");
+        config.setIsTaskConfigured(gitTask.getTaskType(),true);
+
+        TaskScheduler scheduler = new TaskScheduler();
+        scheduler.scheduleTasks();
+    }
+//
+    // Todo Need a way to test termination of execution thread.
+
+//    @Test
+//    public void testTerminateThread(){
+//
+//    }
+
+    class TestTaskExecutorHelper extends TaskExecutor {
+
+        File testGitDir;
+        public TestTaskExecutorHelper(Task maintenanceTask,File testGitDir) {
+            super(maintenanceTask);
+            this.testGitDir = testGitDir;
+        }
+
+        List<GitMaintenanceSCM.Cache> getCaches(){
+            List<GitMaintenanceSCM.Cache> caches = new ArrayList<>();
+            caches.add(new GitMaintenanceSCM.Cache(testGitDir,new ReentrantLock()));
+            return caches;
+        }
+    }
+
+    static List<Integer> getGitVersion(){
+
+        final TaskListener procListener = StreamTaskListener.fromStderr();
+        final ByteArrayOutputStream out = new ByteArrayOutputStream();
+        try {
+            new Launcher.LocalLauncher(procListener).launch().cmds("git", "--version").stdout(out).join();
+        } catch (IOException | InterruptedException ex) {
+            throw new RuntimeException("Couldn't fetch git maintenance command");
+        }
+        String versionOutput = "";
+        try {
+            versionOutput = out.toString(StandardCharsets.UTF_8.toString()).trim();
+        } catch (UnsupportedEncodingException ue) {
+            throw new RuntimeException("Unsupported encoding version");
+        }
+        final String[] fields = versionOutput.split(" ")[2].replaceAll("msysgit.", "").replaceAll("windows.", "").split("\\.");
+
+        // Eg: [2, 31, 4]
+        // 0th index is Major Version.
+        // 1st index is Minor Version.
+        // 2nd index is Patch Version.
+        return Arrays.stream(fields).map(Integer::parseInt).collect(Collectors.toList());
+    }
+}
diff --git a/src/test/java/jenkins/plugins/git/maintenance/TaskSchedulerTest.java b/src/test/java/jenkins/plugins/git/maintenance/TaskSchedulerTest.java
new file mode 100644
index 0000000000..1b9937fe3c
--- /dev/null
+++ b/src/test/java/jenkins/plugins/git/maintenance/TaskSchedulerTest.java
@@ -0,0 +1,165 @@
+package jenkins.plugins.git.maintenance;
+
+import jenkins.model.GlobalConfiguration;
+import jenkins.plugins.git.GitSampleRepoRule;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.jvnet.hudson.test.JenkinsRule;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+public class TaskSchedulerTest {
+
+    @Rule
+    public JenkinsRule j = new JenkinsRule();
+
+    @Rule
+    public GitSampleRepoRule sampleRepo1 = new GitSampleRepoRule();
+
+    private TaskScheduler taskScheduler;
+    private MaintenanceTaskConfiguration config;
+
+    @Before
+    public void setUp() throws Exception {
+        taskScheduler = new TaskScheduler();
+        config = new MaintenanceTaskConfiguration();
+    }
+
+    // Tested all the internal functions of this method
+    @Test
+    public void testScheduleTasks() {
+        config.setIsGitMaintenanceRunning(true);
+        config.setCronSyntax(TaskType.PREFETCH,"* * * * *");
+        config.setIsTaskConfigured(TaskType.PREFETCH,true);
+        taskScheduler.scheduleTasks();
+    }
+
+    @Test
+    public void testCheckIsTaskInQueue(){
+        config.setCronSyntax(TaskType.PREFETCH,"* * * * *");
+        config.setIsTaskConfigured(TaskType.PREFETCH,true);
+
+        config.setCronSyntax(TaskType.COMMIT_GRAPH,"* * * * *");
+        config.setIsTaskConfigured(TaskType.COMMIT_GRAPH,true);
+
+        List<Task> maintenanceTasks = config.getMaintenanceTasks();
+        taskScheduler.addTasksToQueue(maintenanceTasks);
+
+        List<Task> configuredTask = config.getMaintenanceTasks().stream().filter(Task::getIsTaskConfigured).collect(Collectors.toList());
+
+        configuredTask.forEach(task -> assertTrue(taskScheduler.checkIsTaskInQueue(task)));
+    }
+
+    @Test
+    public void testAddTasksToQueue() {
+        // Adding Maintenance tasks configuration;
+        config.setCronSyntax(TaskType.PREFETCH,"* * * * *");
+        config.setIsTaskConfigured(TaskType.PREFETCH,true);
+        config.setCronSyntax(TaskType.LOOSE_OBJECTS,"* * * * *");
+        config.setIsTaskConfigured(TaskType.LOOSE_OBJECTS,true);
+
+        config.setCronSyntax(TaskType.GC,"5 1 1 1 1");
+        config.setIsTaskConfigured(TaskType.GC,true);
+        config.setCronSyntax(TaskType.COMMIT_GRAPH,"H * * * *");
+        List<Task> maintenanceTasks = config.getMaintenanceTasks();
+
+        int length = 2;
+
+        taskScheduler.addTasksToQueue(maintenanceTasks);
+        assertThat(taskScheduler.getMaintenanceQueue().size(),is(length));
+    }
+
+    @Test
+    public void testInvalidAddTasksToQueue() {
+        config.setCronSyntax(TaskType.PREFETCH,"*****");
+        config.setIsTaskConfigured(TaskType.PREFETCH,true);
+        List<Task> maintenanceTasks = config.getMaintenanceTasks();
+        taskScheduler.addTasksToQueue(maintenanceTasks);
+        assertThat(taskScheduler.getMaintenanceQueue().size(),is(0));
+    }
+
+    @Test
+    public void testIsGitMaintenanceTaskRunning(){
+        // Setting value to true
+        config.setIsGitMaintenanceRunning(true);
+        boolean isGitMaintenanceTaskRunning = taskScheduler.isGitMaintenanceTaskRunning(config);
+        assertTrue(isGitMaintenanceTaskRunning);
+
+        // set value to false
+        config.setIsGitMaintenanceRunning(false);
+        isGitMaintenanceTaskRunning = taskScheduler.isGitMaintenanceTaskRunning(config);
+        assertFalse(isGitMaintenanceTaskRunning);
+    }
+
+    @Test
+    public void testCreateNoExecutorThread(){
+        config.setCronSyntax(TaskType.PREFETCH,"5 1 1 1 1");
+        config.setIsTaskConfigured(TaskType.PREFETCH,true);
+
+        List<Task> maintenanceTasks = config.getMaintenanceTasks();
+        taskScheduler.addTasksToQueue(maintenanceTasks);
+        taskScheduler.createTaskExecutorThread();
+        assertNull(taskScheduler.getTaskExecutor());
+
+    }
+
+    @Test
+    public void testCreateExecutionThread(){
+
+        config.setCronSyntax(TaskType.PREFETCH,"* * * * *");
+        config.setIsTaskConfigured(TaskType.PREFETCH,true);
+        config.setCronSyntax(TaskType.LOOSE_OBJECTS,"* * * * *");
+        config.setIsTaskConfigured(TaskType.LOOSE_OBJECTS,true);
+        config.setCronSyntax(TaskType.COMMIT_GRAPH,"* * * * *");
+        config.setIsTaskConfigured(TaskType.COMMIT_GRAPH,true);
+        config.setCronSyntax(TaskType.GC,"* * * * *");
+        config.setIsTaskConfigured(TaskType.GC,true);
+
+        List<Task> maintenanceTasks = config.getMaintenanceTasks();
+        taskScheduler.addTasksToQueue(maintenanceTasks);
+        taskScheduler.createTaskExecutorThread();
+        assertTrue(taskScheduler.getTaskExecutor().isAlive());
+    }
+
+    @Test
+    public void testTerminateMaintenanceTask(){
+        taskScheduler.terminateMaintenanceTaskExecution();
+        assertNull(taskScheduler.getTaskExecutor());
+        assertEquals(0,taskScheduler.getMaintenanceQueue().size());
+    }
+
+    // Need to revist this test
+//    @Test
+//    public void testTerminateMaintenanceTaskDuringThreadExecution() throws Exception {
+//        config.setCronSyntax(TaskType.PREFETCH,"* * * * *");
+//        config.setIsTaskConfigured(TaskType.PREFETCH,true);
+//        // Need to add few caches to test if the Thread is being terminated...
+//
+//        sampleRepo1.init();
+//        sampleRepo1.git("checkout", "-b", "bug/JENKINS-42817");
+//        sampleRepo1.write("file", "modified");
+//        sampleRepo1.git("commit", "--all", "--message=dev");
+//
+//        SCMFileSystem.of(j.createFreeStyleProject(), new GitSCM(GitSCM.createRepoList(sampleRepo1.toString(), null), Collections.singletonList(new BranchSpec("*/bug/JENKINS-42817")), null, null, Collections.emptyList()));
+//
+//        List<Task> tasks = config.getMaintenanceTasks();
+//        taskScheduler.addTasksToQueue(tasks);
+//        taskScheduler.createTaskExecutorThread();
+//
+//        assertTrue(taskScheduler.getTaskExecutor().isAlive());
+//        taskScheduler.terminateMaintenanceTaskExecution();
+//        // This test could depend on CPU speed. Faster execution can fail the test.
+//        Thread.sleep(1);
+//        assertFalse(taskScheduler.getTaskExecutor().isAlive());
+//    }
+
+}
diff --git a/src/test/java/jenkins/plugins/git/maintenance/TaskTest.java b/src/test/java/jenkins/plugins/git/maintenance/TaskTest.java
new file mode 100644
index 0000000000..0a96aa9d8d
--- /dev/null
+++ b/src/test/java/jenkins/plugins/git/maintenance/TaskTest.java
@@ -0,0 +1,97 @@
+package jenkins.plugins.git.maintenance;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+
+@RunWith(Parameterized.class)
+public class TaskTest {
+
+    private final Task task;
+    private final TaskType taskType;
+    private final String taskName;
+
+    public TaskTest(Task task, TaskType taskType, String taskName) {
+        this.task = task;
+        this.taskType = taskType;
+        this.taskName = taskName;
+    }
+
+    @Parameterized.Parameters(name = "{0}")
+    public static Collection permuteTasks() {
+        List<Object[]> tasks = new ArrayList<>();
+        for (TaskType taskType : TaskType.values()) {
+            Object[] task = {new Task(taskType), taskType, taskType.getTaskName()};
+            tasks.add(task);
+        }
+
+        return tasks;
+    }
+
+    @Test
+    public void getTaskType() {
+        assertThat(task.getTaskType(), is(taskType));
+    }
+
+    @Test
+    public void getTaskName() {
+        assertThat(task.getTaskName(), is(taskName));
+    }
+
+    @Test
+    public void setIsConfigured() {
+        task.setIsTaskConfigured(true);
+        assertTrue(task.getIsTaskConfigured());
+    }
+
+    @Test
+    public void checkCronSyntax(){
+        String cronSyntax = "* * 1 * 1";
+        task.setCronSyntax(cronSyntax);
+        assertThat(task.getCronSyntax(), is(cronSyntax));
+    }
+
+    @Test
+    public void testGetTaskType() {
+        assertThat(task.getTaskType(), is(taskType));
+    }
+
+    @Test
+    public void testGetTaskName() {
+        assertThat(task.getTaskName(), is(taskName));
+    }
+
+    @Test
+    public void testGetCronSyntax(){
+        String cronSyntax = "* * 1 * 1";
+        task.setCronSyntax(cronSyntax);
+        assertThat(task.getCronSyntax(), is(cronSyntax));
+    }
+
+    @Test
+    public void testSetIsTaskConfigured() {
+        task.setIsTaskConfigured(true);
+        assertTrue(task.getIsTaskConfigured());
+    }
+
+    @Test
+    public void testGetIsTaskConfigured() {
+        task.setIsTaskConfigured(true);
+        assertTrue(task.getIsTaskConfigured());
+    }
+
+    @Test
+    public void testGetIsTaskConfiguredFalse() {
+        task.setIsTaskConfigured(false);
+        assertFalse(task.getIsTaskConfigured());
+    }
+}