Add new feature Delete Artifacts with pattern

.gitignore

@@ -1,3 +1,5 @@
 /.idea
 **/*.iml
 target/
+work/
+.vscode/

README.md

@@ -215,6 +215,45 @@ pipeline {
 }
 ```
 
+#### Delete build artifacts matching patterns
+The following configuration has a single rule that utilizes the `Match every build` condition and deletes specific build artifacts based on Ant-style glob patterns defined in the `Include Patterns/Exclude Patterns`.
+
+Here's an example using the include pattern `"**"`, exclude pattern `"**/*.log"` to delete all files except log files:
+
+```groovy
+properties(
+    [
+        buildDiscarder(BuildHistoryManager(
+                [
+                    [
+                        actions: [DeleteArtifactsMatchingPatterns(excludePatterns: '**/*.log', includePatterns: '**')],
+                        conditions: [MatchEveryBuild()]
+                    ]
+                ]
+            )
+        )
+    ]
+)
+
+node {
+
+        sh '''
+        rm -rf *
+        touch test.xml
+        touch testLog.log
+        touch testTxt.txt
+        mkdir -p testFolder
+        touch testFolder/test1.xml
+        touch testFolder/testLog1.log
+        touch testFolder/testTxt1.txt
+        '''
+        archiveArtifacts artifacts: '**', followSymlinks: false
+}
+```
+
+#### Configuration for delete artifacts matching include and exclude patterns
+![feature overview page](./.README/delete-artifacts-matching-patterns-configuration.png)
+
 ## Wiki
 Please refer to the [Wiki](https://github.com/jenkinsci/build-history-manager-plugin/wiki)
 for more detailed information.

src/main/java/pl/damianszczepanik/jenkins/buildhistorymanager/descriptors/actions/DeleteArtifactsMatchingPatternsActionDescriptor.java

@@ -0,0 +1,24 @@
+package pl.damianszczepanik.jenkins.buildhistorymanager.descriptors.actions;
+
+import hudson.Extension;
+import hudson.model.Descriptor;
+import org.jenkinsci.Symbol;
+import pl.damianszczepanik.jenkins.buildhistorymanager.model.actions.Action;
+import pl.damianszczepanik.jenkins.buildhistorymanager.model.actions.DeleteArtifactsMatchingPatternsAction;
+
+/**
+ * Descriptor implementation needed to render UI for {@link DeleteArtifactsMatchingPatternsAction}.
+ */
+@Extension
+@Symbol("DeleteArtifactsMatchingPatterns")
+public class DeleteArtifactsMatchingPatternsActionDescriptor extends Descriptor<Action>{
+
+    public DeleteArtifactsMatchingPatternsActionDescriptor() {
+        super(DeleteArtifactsMatchingPatternsAction.class);
+    }
+
+    @Override
+    public String getDisplayName() {
+        return "Delete artifacts matching patterns";
+    }
+}

src/main/java/pl/damianszczepanik/jenkins/buildhistorymanager/model/actions/DeleteArtifactsMatchingPatternsAction.java

@@ -0,0 +1,147 @@
+package pl.damianszczepanik.jenkins.buildhistorymanager.model.actions;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.DirectoryStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Collection;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.jenkinsci.remoting.RoleChecker;
+import org.kohsuke.stapler.DataBoundConstructor;
+import org.kohsuke.stapler.DataBoundSetter;
+
+import hudson.FilePath;
+import hudson.FilePath.FileCallable;
+import hudson.Util;
+import hudson.model.Run;
+import hudson.remoting.VirtualChannel;
+import jenkins.util.VirtualFile;
+
+/**
+ * Deletes the artifacts matching patterns.
+ */
+public class DeleteArtifactsMatchingPatternsAction extends Action {
+    private static final Logger LOG = Logger.getLogger(DeleteArtifactsMatchingPatternsAction.class.getName());
+
+    private String includePatterns;
+    private String excludePatterns;
+
+    @DataBoundConstructor
+    public DeleteArtifactsMatchingPatternsAction() {
+        // Jenkins stapler requires to have public constructor with @DataBoundConstructor
+    }
+
+    public String getIncludePatterns() {
+        return includePatterns;
+    }
+
+    @DataBoundSetter
+    public void setIncludePatterns(String includePatterns) {
+        this.includePatterns = includePatterns;
+    }
+
+    public String getExcludePatterns() {
+        return excludePatterns;
+    }
+
+    @DataBoundSetter
+    public void setExcludePatterns(String excludePatterns) {
+        this.excludePatterns = excludePatterns;
+    }
+
+    // if 'file' is on a different node, this FileCallable will be transferred to that node and executed there.
+    public static final class DeleteFileCallable implements FileCallable<Void> {
+        private static final long serialVersionUID = 2469669731898204125L;
+        private final File archiveRootDirectory;
+
+        public DeleteFileCallable(File archiveRootDirectory) {
+            this.archiveRootDirectory = archiveRootDirectory;
+        }
+
+        @Override 
+        public Void invoke(File file, VirtualChannel channel) throws IOException {
+            deleteFileOrLogError(file);
+            return null;
+        }
+
+        /**
+         * Deletes the specified directory if it is empty and its parent is the archive root directory.
+         * Additionally, deletes the parent directories recursively.
+         *
+         * @param directory The directory to be deleted.
+         * @throws IOException If an I/O error occurs.
+         */
+        void deleteEmptyDirectoryAndParent(File directory) throws IOException {
+            if (isDirectoryEmpty(directory.toPath()) && isArchiveRootDirectory(directory.getParentFile())) {
+                Util.deleteFile(directory);
+                deleteParentDirectories(directory.getParentFile());
+            }
+        }
+
+        boolean isDirectoryEmpty(Path path) throws IOException {
+            try (DirectoryStream<Path> directoryStream = Files.newDirectoryStream(path)) {
+                return !directoryStream.iterator().hasNext();
+            }
+        }
+
+        boolean isArchiveRootDirectory(File directory) {
+            return this.archiveRootDirectory.equals(directory);
+        }
+
+        void deleteParentDirectories(File directory) {
+            while (!isArchiveRootDirectory(directory)) {
+                deleteDirectory(directory);
+                directory = directory.getParentFile();
+            }
+        }
+
+        void deleteDirectory(File directory) {
+            boolean deleteSuccess = directory.delete();
+            if(!deleteSuccess) {
+                LOG.log(Level.FINE, "Deletion of directory failed: " + directory.getAbsolutePath());
+            }
+        }
+
+        void deleteFileOrLogError(File file) throws IOException {
+            if (file.isFile()) {
+                Util.deleteFile(file);
+                deleteEmptyDirectoryAndParent(file.getParentFile());
+                return;
+            }
+            LOG.log(Level.FINE, file + " is neither a directory nor a regular file.");
+        }
+
+        /**
+         * Overrides the 'checkRoles' method to fulfill the requirement of implementing RoleSensitive.
+         *
+         * @param checker The RoleChecker used for access control and security purposes.
+         * @throws SecurityException If there are security-related issues.
+         */
+        @Override
+        public void checkRoles(RoleChecker checker) throws SecurityException {
+            //Nothing is being done here even though a call to RoleChecker#check(…​) is expected.
+        }
+    }
+
+    @Override
+    public void perform(Run<?, ?> run) throws IOException, InterruptedException {
+        VirtualFile virtualRoot = run.getArtifactManager().root();
+        Collection<String> files = virtualRoot.list(includePatterns, excludePatterns, false);
+        LOG.log(Level.FINE, "Include Pattern Files: " + files);
+
+        for (String path : files) {
+            deleteFileAtPath(virtualRoot, path);
+        }
+    }
+
+    public void deleteFileAtPath(VirtualFile virtualRoot, String path) throws IOException, InterruptedException {
+        VirtualFile virtualFile = virtualRoot.child(path);
+        File file = new File(virtualFile.toURI().getPath());
+        FilePath filePath = new FilePath(file);
+        DeleteFileCallable deleteFileCallableInstance = new DeleteFileCallable(new File(virtualRoot.toURI()));
+        filePath.act(deleteFileCallableInstance);
+    }
+}

src/main/resources/pl/damianszczepanik/jenkins/buildhistorymanager/model/actions/DeleteArtifactsMatchingPatternsAction/config.jelly

@@ -0,0 +1,9 @@
+<?jelly escape-by-default='true'?>
+<j:jelly xmlns:j="jelly:core" xmlns:f="/lib/form">
+    <f:entry title="Patterns to include" field="includePatterns">
+        <f:textbox />
+    </f:entry>
+    <f:entry title="Patterns to exclude" field="excludePatterns">
+        <f:textbox />
+    </f:entry>
+</j:jelly>

src/main/resources/pl/damianszczepanik/jenkins/buildhistorymanager/model/actions/DeleteArtifactsMatchingPatternsAction/help.html

@@ -0,0 +1,16 @@
+<p><b>Description</b></p>
+<p>Deletes build artifacts that match the Ant-style glob patterns provided.</p>
+<p><b>Include Patterns</b></p>
+<p>The include pattern is a comma-separated list of Ant-style globs that follows a specific format.
+    The path separator for this format is the forward slash (/) and an empty string is used in the include pattern to indicate that there are no matches.
+    If the goal is to match everything except for certain files (defined as "Exclude Patterns"), then the recommended approach is to use the value <code>**</code> here and call out exclusions below.</p>
+<p><b>Exclude Patterns</b></p>
+<p>The exclude pattern is an optional input that should be in the same format as the include pattern.</p>
+<p><b>Use cases</b></p>
+<p>To delete artifacts with a specific file extension, for example use the include pattern "**/*.log" to delete all the log files.</p>
+<p>To keep artifacts with a specific file extension, for example use the exclude pattern "**/*.log" to delete everything except the log files.</p>
+
+<p><b>Warning!</b></p>
+<p>It is important to note that this feature should be used with caution as it can be permanently
+    delete artifacts that may be important for later reference or analysis. It is recommended that users
+    carefully review the pattern and build history before executing the deletion.</p>

src/test/java/pl/damianszczepanik/jenkins/buildhistorymanager/descriptors/actions/DeleteArtifactsMatchingPatternsActionDescriptorTest.java

@@ -0,0 +1,29 @@
+package pl.damianszczepanik.jenkins.buildhistorymanager.descriptors.actions;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import hudson.model.AbstractDescribableImpl;
+import hudson.model.Descriptor;
+import org.jenkinsci.plugins.structs.SymbolLookup;
+import org.junit.Rule;
+import org.junit.Test;
+import org.jvnet.hudson.test.JenkinsRule;
+
+public class DeleteArtifactsMatchingPatternsActionDescriptorTest {
+
+    @Rule
+    public JenkinsRule j = new JenkinsRule();
+
+    @Test
+    public void getDisplayName_ReturnsDescriptorName() {
+
+        // given
+        Descriptor descriptor = SymbolLookup.get().findDescriptor(AbstractDescribableImpl.class, "DeleteArtifactsMatchingPatterns");
+
+        // when
+        String displayName = descriptor.getDisplayName();
+
+        // then
+        assertThat(displayName).isEqualTo("Delete artifacts matching patterns");
+    }
+}