Upload 74 files

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+data/docs/docs.index filter=lfs diff=lfs merge=lfs -text
+model_cache/models--sentence-transformers--all-MiniLM-L6-v2/blobs/53aa51172d142c89d9012cce15ae4d6cc0ca6895895114379cacb4fab128d9db filter=lfs diff=lfs merge=lfs -text
+model_cache/models--sentence-transformers--paraphrase-MiniLM-L3-v2/blobs/cf1e4e2d420c664973037c3c73125d7a8fc69952495093ef8f50596f8943a433 filter=lfs diff=lfs merge=lfs -text

data/docs/docs.index

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:82147cb1af5ba65eeb65590c97483e0040900e4aa8bcdff006387b0b989e0cbe
+size 937005

data/docs/docs_meta.json

@@ -0,0 +1,2442 @@
+[
+  {
+    "source_file": "git_scm.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "git_scm.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "git_scm.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "git_scm.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "git_scm.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "git_scm.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "git_scm.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "git_scm.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "git_scm.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "git_scm.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "git_scm.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "git_scm.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "git_scm.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "git_scm.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "git_scm.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "git_scm.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "git_scm.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "git_scm.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "git_scm.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "git_scm.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "git_scm.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "git_scm.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "git_scm.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "git_scm.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "git_scm.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "git_scm.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_credentials_text.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_credentials_text.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_credentials_text.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_credentials_text.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_credentials_text.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_credentials_text.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_credentials_text.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_credentials_text.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_credentials_text.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_credentials_text.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_credentials_text.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_credentials_text.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_credentials_text.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_credentials_text.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_git.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_git.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_git.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_git.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_git.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_git.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_git.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_git.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_git.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_git.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_git.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_git.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_git.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_git.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_git.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_git.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_git.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_nodes.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_nodes.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_nodes.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_nodes.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_nodes.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_nodes.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_nodes.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_nodes.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_nodes.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_nodes.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_nodes.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_nodes.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_nodes.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_nodes.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_nodes.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_nodes.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_nodes.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_nodes.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "jenkins_nodes.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_steps.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "pipeline_syntax.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  },
+  {
+    "source_file": "using_a_jenkinsfile.txt",
+    "source": "https://www.jenkins.io/doc/"
+  }
+]

data/docs/raw/git_scm.txt

@@ -0,0 +1,206 @@
+The following plugin provides functionality available through Pipeline-compatible steps. Read more about how to integrate steps into your Pipeline in the Steps section of the Pipeline Syntax page.
+
+For a list of other such plugins, see the Pipeline Steps Reference page.
+
+scmGit
+scmGit
+The git plugin provides fundamental git operations for Jenkins projects. It can poll, fetch, checkout, and merge contents of git repositories.
+
+The scmGit parameter of the git plugin is used with the Pipeline SCM checkout step to checkout git repositories into Pipeline workspaces. The Pipeline Syntax Snippet Generator guides the user to select git plugin checkout options and provides online help for each of the options.
+
+Use the Pipeline Snippet Generator to generate a sample pipeline script for the checkout step. Examples of the checkout step include:
+
+Checkout step with defaults
+Checkout step with https and a specific branch
+Checkout step with ssh and a private key credential
+Checkout step with https and changelog disabled
+Checkout step with git protocol and polling disabled
+See the argument descriptions for more details.
+The scmGit parameter of the checkout step provides access to all the Pipeline capabilities provided by the git plugin:
+
+checkout scmGit(userRemoteConfigs: [
+                    [ url: 'https://github.com/jenkinsci/git-plugin' ]
+                ])
+NOTE: The checkout step with the scmGit parameter is the preferred SCM checkout method. For simpler cases that do not require all the capabilities of the git plugin, the git step can also be used.
+
+Use the Pipeline Snippet Generator to generate a sample pipeline script for the checkout step.
+
+The checkout step with the scmGit parameter can be used in many cases where the git step cannot be used. Refer to the git plugin documentation for detailed descriptions of options available to the checkout step. For example, the checkout step supports:
+
+SHA-1 checkout
+Tag checkout
+Submodule checkout
+Sparse checkout
+Large file checkout (LFS)
+Reference repositories
+Branch merges
+Repository tagging
+Custom refspecs
+Timeout configuration
+Changelog calculation against a non-default reference
+Stale branch pruning
+Example: Checkout step with defaults
+Checkout from the git plugin source repository using https protocol, no credentials, and the master branch.
+
+The Pipeline Snippet Generator generates this example:
+
+checkout scmGit(userRemoteConfigs: [
+                    [ url: 'https://github.com/jenkinsci/git-plugin' ]
+                ])
+Example: Checkout step with https and a specific branch
+Checkout from the Jenkins source repository using https protocol, no credentials, and a specific branch (stable-2.289).
+
+The Pipeline Snippet Generator generates this example:
+
+checkout scmGit(branches: [[name: 'stable-2.289']],
+                userRemoteConfigs: [
+                    [ url: 'https://github.com/jenkinsci/jenkins.git' ]
+                ])
+Example: Checkout step with ssh and a private key credential
+Checkout from the git client plugin source repository using ssh protocol, private key credentials, and the master branch. The credential must be a private key credential if the remote git repository is accessed with the ssh protocol. The credential must be a username / password credential if the remote git repository is accessed with http or https protocol.
+
+The Pipeline Snippet Generator generates this example:
+
+checkout changelog: false,
+         scm: scmGit(userRemoteConfigs: [
+                         [ credentialsId: 'my-private-key-credential-id',
+                           url: 'git@github.com:jenkinsci/git-client-plugin.git' ]
+                     ])
+Example: Checkout step with https and changelog disabled
+Checkout from the Jenkins source repository using https protocol, no credentials, the master branch, and changelog calculation disabled. If changelog is false, then the changelog will not be computed for this job. If changelog is true or is not set, then the changelog will be computed. See the workflow scm step documentation for more changelog details.
+
+The Pipeline Snippet Generator generates this example:
+
+checkout changelog: false,
+         scm: scmGit(userRemoteConfigs: [
+                         [ url: 'https://github.com/jenkinsci/credentials-plugin' ]
+                     ])
+Example: Checkout step with git protocol and polling disabled
+Checkout from the command line git repository using git protocol, no credentials, the master branch, and no polling for changes. If poll is false, then the remote repository will not be polled for changes. If poll is true or is not set, then the remote repository will be polled for changes. See the workflow scm step documentation for more polling details.
+
+The Pipeline Snippet Generator generates this example:
+
+checkout poll: false,
+         scm: scmGit(userRemoteConfigs: [
+                         [ url: 'git://git.kernel.org/pub/scm/git/git.git' ]
+                     ])
+Argument Descriptions
+userRemoteConfigs
+Specify the repository to track. This can be a URL or a local file path. Note that for super-projects (repositories with submodules), only a local file path or a complete URL is valid. The following are examples of valid git URLs.
+ssh://git@github.com/github/git.git
+git@github.com:github/git.git (short notation for ssh protocol)
+ssh://user@other.host.com/~/repos/R.git (to access the repos/R.git repository in the user's home directory)
+https://github.com/github/git.git
+
+If the repository is a super-project, the location from which to clone submodules is dependent on whether the repository is bare or non-bare (i.e. has a working directory).
+If the super-project is bare, the location of the submodules will be taken from .gitmodules.
+If the super-project is not bare, it is assumed that the repository has each of its submodules cloned and checked out appropriately. Thus, the submodules will be taken directly from a path like ${SUPER_PROJECT_URL}/${SUBMODULE}, rather than relying on information from .gitmodules.
+For a local URL/path to a super-project, git rev-parse --is-bare-repository is used to detect whether the super-project is bare or not.
+For a remote URL to a super-project, the ending of the URL determines whether a bare or non-bare repository is assumed:
+If the remote URL ends with .git, a non-bare repository is assumed.
+If the remote URL does NOT end with .git, a bare repository is assumed.
+Array / List of Nested Object
+url : String
+name : String
+refspec : String
+credentialsId : String
+branches
+List of branches to build. Jenkins jobs are most effective when each job builds only a single branch. When a single job builds multiple branches, the changelog comparisons between branches often show no changes or incorrect changes.
+Array / List of Nested Object
+name : String
+browser
+Defines the repository browser that displays changes detected by the git plugin.
+Nested Choice of Objects
+assembla
+$class: 'BacklogGitRepositoryBrowser'
+bitbucketServer
+bitbucket
+cgit
+fisheye
+gitblit
+$class: 'GitBucketBrowser'
+gitLab
+gitLabBrowser
+gitList
+gitWeb
+$class: 'GiteaBrowser'
+github
+gitiles
+$class: 'GitoriousWeb'
+gogs
+kiln
+phabricator
+redmine
+rhodeCode
+$class: 'ScmManagerGitRepositoryBrowser'
+jbSpace
+$class: 'Stash'
+teamFoundation
+$class: 'TracGitRepositoryBrowser'
+$class: 'TuleapBrowser'
+viewgit
+gitTool : String
+Name of the git tool to be used for this job. Git tool names are defined in "Global Tool Configuration".
+
+extensions
+Extensions add new behavior or modify existing plugin behavior for different uses. Extensions help users more precisely tune plugin behavior to meet their needs.
+
+Extensions include:
+
+Clone extensions modify the git operations that retrieve remote changes into the agent workspace. The extensions can adjust the amount of history retrieved, how long the retrieval is allowed to run, and other retrieval details.
+Checkout extensions modify the git operations that place files in the workspace from the git repository on the agent. The extensions can adjust the maximum duration of the checkout operation, the use and behavior of git submodules, the location of the workspace on the disc, and more.
+Changelog extensions adapt the source code difference calculations for different cases.
+Tagging extensions allow the plugin to apply tags in the current workspace.
+Build initiation extensions control the conditions that start a build. They can ignore notifications of a change or force a deeper evaluation of the commits when polling.
+Merge extensions can optionally merge changes from other branches into the current branch of the agent workspace. They control the source branch for the merge and the options applied to the merge.
+Array / List of Nested Choice of Objects
+authorInChangelog
+$class: 'BitbucketEnvVarExtension'
+$class: 'BuildChooserSetting'
+buildSingleRevisionOnly
+changelogToBranch
+checkoutOption
+cleanBeforeCheckout
+cleanAfterCheckout
+cloneOption
+$class: 'CodeCommitURLHelper'
+$class: 'DisableRemotePoll'
+$class: 'ExcludeFromChangeSet'
+$class: 'ExcludeFromPoll'
+$class: 'FallbackToOtherRepositoryGitSCMExtension'
+firstBuildChangelog
+$class: 'GitClientAuthenticatorExtension'
+lfs
+$class: 'GitSCMChecksExtension'
+$class: 'GitSCMStatusChecksExtension'
+$class: 'GitTagMessageExtension'
+$class: 'IgnoreNotifyCommit'
+localBranch
+$class: 'MessageExclusion'
+$class: 'PathRestriction'
+perBuildTag
+$class: 'PreBuildMerge'
+pretestedIntegration
+pruneStaleBranch
+pruneTags
+$class: 'RelativeTargetDirectory'
+$class: 'ScmName'
+sparseCheckout
+submodule
+$class: 'UserExclusion'
+$class: 'UserIdentity'
+$class: 'WipeWorkspace'
+doGenerateSubmoduleConfigurations : boolean (optional)
+Removed facility that was intended to test combinations of git submodule versions. Removed in git plugin 4.6.0. Ignores the user provided value and always uses false as its value.
+
+submoduleCfg (optional)
+Removed facility that was intended to test combinations of git submodule versions. Removed in git plugin 4.6.0. Ignores the user provided value(s) and always uses empty values.
+
+Array / List of Nested Object
+submoduleName : String
+Removed in git plugin 4.6.0.
+
+branches : Array / List of String
+Removed in git plugin 4.6.0.
+
+Was this page helpful?

data/docs/raw/jenkins_credentials_text.txt

@@ -0,0 +1,125 @@
+The following plugin provides functionality available through Pipeline-compatible steps. Read more about how to integrate steps into your Pipeline in the Steps section of the Pipeline Syntax page.
+
+For a list of other such plugins, see the Pipeline Steps Reference page.
+
+Table of Contents
+Credentials Binding Plugin
+withCredentials: Bind credentials to variables
+Credentials Binding Plugin
+View this plugin on the Plugins site
+
+withCredentials: Bind credentials to variables
+Allows various kinds of credentials (secrets) to be used in idiosyncratic ways. (Some steps explicitly ask for credentials of a particular kind, usually as a credentialsId parameter, in which case this step is unnecessary.) Each binding will define an environment variable active within the scope of the step. You can then use them directly from any other steps that expect environment variables to be set:
+
+node {
+  withCredentials([usernameColonPassword(credentialsId: 'mylogin', variable: 'USERPASS')]) {
+    sh '''
+      set +x
+      curl -u "$USERPASS" https://private.server/ > output
+    '''
+  }
+}
+As another example (use Snippet Generator to see all options):
+
+node {
+  withCredentials([string(credentialsId: 'mytoken', variable: 'TOKEN')]) {
+    sh '''
+      set +x
+      curl -H "Token: $TOKEN" https://some.api/
+    '''
+  }
+}
+Note the use of single quotes to define the script (implicit parameter to sh) in Groovy above. You want the secret to be expanded by the shell as an environment variable. The following idiom is potentially less secure, as the secret is interpolated by Groovy and so (for example) typical operating system process listings will accidentally disclose it:
+
+node {
+  withCredentials([string(credentialsId: 'mytoken', variable: 'TOKEN')]) {
+    sh /* WRONG! */ """
+      set +x
+      curl -H 'Token: $TOKEN' https://some.api/
+    """
+  }
+}
+At least on Linux, environment variables can be obtained by other processes running in the same account, so you should not run a job which uses secrets on the same node as a job controlled by untrusted parties. In any event, you should always prefer expansion as environment variables to inclusion in the command, since Jenkins visualizations such as Blue Ocean will attempt to detect step parameters containing secrets and refuse to display them.
+
+The secret(s) will be masked (****) in case they are printed to the build log. This prevents you from accidentally disclosing passwords and the like via the log. (Bourne shell set +x, or Windows batch @echo off, blocks secrets from being displayed in echoed commands; but build tools in debug mode might dump all environment variables to standard output/error, or poorly designed network clients might display authentication, etc.) The masking could of course be trivially circumvented; anyone permitted to configure a job or define Pipeline steps is assumed to be trusted to use any credentials in scope however they like.
+
+Beware that certain tools mangle secrets when displaying them. As one example, Bash (as opposed to Ubuntu’s plainer Dash) does so with text containing ' in echo mode:
+
+$ export PASS=foo"'"bar
+$ env|fgrep PASS
+PASS=foo'bar
+$ sh -xc 'echo $PASS'
++ echo foo'bar
+foo'bar
+$ bash -xc 'echo $PASS'
++ echo 'foo'\''bar'
+foo'bar
+Mangled secrets can only be detected on a best-effort basis. By default, Jenkins will attempt to mask mangled secrets as they would appear in output of Bourne shell, Bash, Almquist shell and Windows batch. Without these strategies in place, mangled secrets would appear in plain text in log files. In the example above, this would result in:
+
++ echo 'foo'\''bar'
+****
+This particular issue can be more safely prevented by turning off echo with set +x or avoiding the use of shell metacharacters in secrets.
+
+For bindings which store a secret file, beware that
+
+node {
+  dir('subdir') {
+    withCredentials([file(credentialsId: 'secret', variable: 'FILE')]) {
+      sh 'use $FILE'
+    }
+  }
+}
+is not safe, as $FILE might be inside the workspace (in subdir@tmp/secretFiles/), and thus visible to anyone able to browse the job’s workspace. If you need to run steps in a different directory than the usual workspace, you should instead use
+
+node {
+  withCredentials([file(credentialsId: 'secret', variable: 'FILE')]) {
+    dir('subdir') {
+      sh 'use $FILE'
+    }
+  }
+}
+to ensure that the secrets are outside the workspace; or choose a different workspace entirely:
+
+node {
+  ws {
+    withCredentials([file(credentialsId: 'secret', variable: 'FILE')]) {
+      sh 'use $FILE'
+    }
+  }
+}
+Also see the Limitations of Credentials Masking blog post for more background.
+
+bindings
+Array / List of Nested Choice of Objects
+aws
+token
+$class: 'AwsBucketCredentialsBinding'
+ociCredentials
+certificate
+ConjurSecretApplianceCredentials
+conjurSecretCredential
+conjurSecretDockerClientCert
+conjurSecretFile
+conjurSecretString
+conjurSecretUsername
+conjurSecretUsernameSSHKey
+dockerCert
+file
+gitlabApiToken
+gitUsernamePassword
+$class: 'KeychainPasswordAndPathBinding'
+OSFBuilderSuiteOpenCommerceAPICredentials
+sshUserPrivateKey
+string
+OSFBuilderSuiteTwoFactorAuthCredentials
+usernameColonPassword
+usernamePassword
+$class: 'VaultCertificateCredentialsBinding'
+vaultFile
+$class: 'VaultSSHUserPrivateKeyBinding'
+vaultString
+$class: 'VaultTokenCredentialBinding'
+$class: 'VaultUsernamePasswordCredentialBinding'
+zip
+azureServicePrincipal
+azureStorage

data/docs/raw/jenkins_git.txt

@@ -0,0 +1,110 @@
+The following plugin provides functionality available through Pipeline-compatible steps. Read more about how to integrate steps into your Pipeline in the Steps section of the Pipeline Syntax page.
+
+For a list of other such plugins, see the Pipeline Steps Reference page.
+
+Table of Contents
+Git plugin
+git: Git
+Git plugin
+View this plugin on the Plugins site
+
+git: Git
+The git step performs a clone from the specified repository into a Pipeline workspace.
+
+Use the Pipeline Syntax Snippet Generator to generate a sample pipeline script for the git step. More advanced checkout operations require the checkout step with the scmGit parameter rather than the git step. Examples of the git step include:
+
+Git step with defaults
+Git step with https and a specific branch
+Git step with ssh and a private key credential
+Git step with https and changelog disabled
+Git step with git protocol and polling disabled
+See the argument descriptions for more details.
+The git step is a simplified shorthand for a subset of the more powerful checkout step with the scmGit parameter:
+
+checkout scmGit(branches: [[name: 'main']],
+    userRemoteConfigs: [[url: 'https://git-server/user/repository.git']])
+NOTE: The checkout step with the scmGit parameter is the preferred SCM checkout method. It provides significantly more functionality than the git step.
+
+Use the Pipeline Syntax Snippet Generator to generate a sample pipeline script for the checkout step.
+
+The checkout step with the scmGit parameter can be used in many cases where the git step cannot be used. Refer to the git plugin documentation for detailed descriptions of options available to the scmGit parameter of the checkout step. For example, the git step does not support:
+
+SHA-1 checkout
+Tag checkout
+Submodule checkout
+Sparse checkout
+Large file checkout (LFS)
+Reference repositories
+Branch merges
+Repository tagging
+Custom refspecs
+Timeout configuration
+Changelog calculation against a non-default reference
+Stale branch pruning
+Example: Git step with defaults
+Checkout from the git plugin source repository using https protocol, no credentials, and the master branch.
+
+The Pipeline Syntax Snippet Generator generates this example:
+
+git 'https://github.com/jenkinsci/git-plugin.git'
+Example: Git step with https and a specific branch
+Checkout from the Jenkins source repository using https protocol, no credentials, and a specific branch (stable-2.492). Note that this must be a local branch name like 'master' or 'develop'.
+
+Branch names that are not supported by the git step
+
+Remote branch names like 'origin/master' and 'origin/develop' are not supported as the branch argument
+SHA-1 hashes are not supported as the branch argument
+Tag names are not supported as the branch argument
+Remote branch names, SHA-1 hashes, and tag names are supported by the general purpose scmGit parameter of the checkout step.
+
+The Pipeline Syntax Snippet Generator generates this example:
+
+git branch: 'stable-2.492',
+    url: 'https://github.com/jenkinsci/jenkins.git'
+Example: Git step with ssh and a private key credential
+Checkout from the git client plugin source repository using ssh protocol, private key credentials, and the master branch. The credential must be a private key credential if the remote git repository is accessed with the ssh protocol. The credential must be a username / password credential if the remote git repository is accessed with http or https protocol.
+
+The Pipeline Syntax Snippet Generator generates this example:
+
+git credentialsId: 'my-private-key-credential-id',
+    url: 'git@github.com:jenkinsci/git-client-plugin.git'
+Example: Git step with https and changelog disabled
+Checkout from the Jenkins source repository using https protocol, no credentials, the master branch, and changelog calculation disabled. If changelog is false, then the changelog will not be computed for this job. If changelog is true or is not set, then the changelog will be computed. See the workflow scm step documentation for more changelog details.
+
+The Pipeline Syntax Snippet Generator generates this example:
+
+git changelog: false,
+    url: 'https://github.com/jenkinsci/credentials-plugin.git'
+Example: Git step with https protocol and polling disabled
+Checkout from the Jenkins platform labeler repository using https protocol, no credentials, the master branch, and no polling for changes. If poll is false, then the remote repository will not be polled for changes. If poll is true or is not set, then the remote repository will be polled for changes. See the workflow scm step documentation for more polling details.
+
+The Pipeline Syntax Snippet Generator generates this example:
+
+git poll: false,
+    url: 'https://github.com/jenkinsci/platformlabeler-plugin.git'
+Argument Descriptions
+url : String
+URL of the repository to be checked out in the workspace. Required parameter.
+
+Repository URL's should follow the git URL guidelines. Git steps to access a secured repository should provide a Jenkins credential with the credentialsId argument rather than embedding credentials in the URL. Credentials embedded in a repository URL may be visible in console logs or in other log files.
+
+branch : String (optional)
+Branch to be checked out in the workspace. Default is 'master'.
+
+Note that this must be a local branch name like 'master' or 'develop'. Remote branch names like 'origin/master' and 'origin/develop' are not supported as the branch argument. Tag names are not supported as the branch argument. SHA-1 hashes are not supported as the branch argument. Remote branch names, tag names, and SHA-1 hashes are supported by the general purpose checkout step with the scmGit parameter.
+
+changelog : boolean (optional)
+Compute changelog for this job. Default is 'true'.
+
+If changelog is false, then the changelog will not be computed for this job. If changelog is true or is not set, then the changelog will be computed.
+
+credentialsId : String (optional)
+Identifier of the credential used to access the remote git repository. Default is '<empty>'.
+
+The credential must be a private key credential if the remote git repository is accessed with the ssh protocol. The credential must be a username / password credential if the remote git repository is accessed with http or https protocol.
+
+poll : boolean (optional)
+Poll remote repository for changes. Default is 'true'.
+
+If poll is false, then the remote repository will not be polled for changes. If poll is true or is not set, then the remote repository will be polled for changes.
+

data/docs/raw/jenkins_nodes.txt

@@ -0,0 +1,171 @@
+Managing Nodes 
+Table of Contents
+Components of Distributed Builds
+Creating Agents
+Launch inbound agent via Windows Scheduler
+Installing a Jenkins agent on Windows
+Creating a macOS agent for Jenkins
+Components of Distributed Builds
+Builds in a distributed builds architecture use nodes, agents, and executors, which are distinct from the Jenkins controller itself. Understanding what each of these components are is useful when managing nodes:
+
+Jenkins controller
+The Jenkins controller is the Jenkins service itself and where Jenkins is installed. It is also a web server that also acts as a "brain" for deciding how, when, and where to run tasks. Management tasks such as configuration, authorization, and authentication are executed on the controller, which serves HTTP requests. Files written when a Pipeline executes are written to the filesystem on the controller, unless they are off-loaded to an artifact repository such as Nexus or Artifactory.
+
+Nodes
+Nodes are the "machines" on which build agents run. Jenkins monitors each attached node for disk space, free temp space, free swap, clock time/sync, and response time. A node is taken offline if any of these values go outside the configured threshold. Jenkins supports two types of nodes:
+
+agents (described below)
+
+built-in node
+
+The built-in node is a node that exists within the controller process. It is possible to use agents and the build-in node to run tasks. However, running tasks on the built-in node is discouraged for security, performance, and scalability reasons. The number of executors configured for the node determines the node’s ability to run tasks. Set the number of executors to 0 to disable running tasks on the built-in node.
+
+Agents
+Agents manage the task execution on behalf of the Jenkins controller by using executors. An agent is a small (170KB single jar) Java client process that connects to a Jenkins controller and is assumed to be unreliable. An agent can use any operating system that supports Java. Any tools required for building and testing get installed on the node where the agent runs. Because these tools are a part of the node, they can be installed directly or in a container, such as Docker or Kubernetes. Each agent is effectively a process with its own Process Identifier (PID) on the host machine. In practice, nodes and agents are essentially the same but it is good to remember that they are conceptually distinct.
+
+Executors
+An executor is a slot for the execution of tasks. Effectively, it is a thread in the agent. The number of executors on a node defines the number of concurrent tasks that can run. In other words, this determines the number of concurrent Pipeline stages that can execute at the same time. Determine the correct number of executors per build node must be determined based on the resources available on the node and the resources required for the workload. When determining how many executors to run on a node, consider CPU and memory requirements, as well as the amount of I/O and network activity:
+
+One executor per node is the safest configuration.
+
+One executor per CPU core can work well, if the tasks running are small.
+
+Monitor I/O performance, CPU load, memory usage, and I/O throughput carefully when running multiple executors on a node.
+
+Creating Agents
+Jenkins agents are the "workers" that perform operations requested by the Jenkins controller. The Jenkins controller administers the agents and can manage the tooling on the agents. Jenkins agents may be statically allocated or they can be dynamically allocated through systems like Kubernetes, OpenShift, Amazon EC2, Azure, Google Cloud, IBM Cloud, Oracle Cloud, and other cloud providers.
+
+This 30 minute tutorial from Darin Pope creates a Jenkins agent and connects it to a controller.
+
+How to create an agent node in Jenkins
+
+Launch inbound agent via Windows Scheduler
+If you are having trouble getting the inbound agent installed as a Windows service (i.e., you followed the instructions on installing the agent as a service here but it didn’t work), an alternative method of starting the service automatically when Windows starts is to use the Windows Scheduler. 
+
+We take advantage of the Windows Scheduler’s ability to run command at system startup
+
+Configure your node to use the "Launch agents by connecting it to the master" launch method
+
+Click Save
+
+Note the command required to launch the agent
+
+On the new agent node’s Jenkins page, note the agent command line shown. 
+
+It will be like:
+
+java \
+    -jar agent.jar \
+    -url <Jenkins URL> \
+    -secret <secret key> \
+    -name <agent name>
+Obtain the agent.jar file and copy it to your new Windows agent node
+
+In the command line noted in the last step, the "agent.jar" is a hyperlink. Click it to download the agent.jar file.
+
+Copy the agent.jar file to a permanent location on your agent machine
+
+Ensure that you have a java version available on your agent machine
+
+If not, obtain and install a supported version of Java
+
+Run the command manually from a CMD window on your agent to confirm that it works
+
+Open the CMD window
+
+Run the command the one like
+
+java \
+    -jar agent.jar \
+    -url <Jenkins URL> \
+    -secret <secret key> \
+    -name <agent name>
+Go back to the node’s web page in Jenkins.  If everything works then page should say "Agent is connected"
+
+Stop the command (control-c)
+
+Register a new scheduled job to run the same command
+
+Open "Task Scheduler" on your windows machine
+
+Start → Run: task Scheduler
+
+Create a basic task (Menu: Action → Create Basic Task)
+
+First page of the wizard:
+
+Name: Jenkins Agent
+
+Description (optional)
+
+Click Next
+
+Next page of the wizard
+
+When do you want the task to start: select "When the computer starts"
+
+Click Next
+
+Next page of the wizard
+
+What action do you want the task to perform: select "Start a program"
+
+Click Next
+
+Next page of the wizard
+
+Program/Script: enter "java.exe" (or the full path to your java.exe)
+
+Add arguments: enter the rest of the command, like
+
+java
+    -jar agent.jar \
+    -url <Jenkins URL> \
+    -secret <secret key> \
+    -name <agent name>
+eg:
+
+java \
+    -jar D:\Scripts\jenkins\agent.jar \
+    -url http://jenkinshost.example.com \
+    -secret d6a84df1fc4f45ddc9c6ab34b08f13391983ffffffffffb3488b7d5ac77fbc7 \
+    -name buildNode1
+Click Next
+
+Next page of the wizard
+
+Click the check box "Open the Properties dialog for this task when I click Finish
+
+Click Finish
+
+Update the task’s properties
+
+On the General tab
+
+Select the user to run the task as
+
+Select "Run whether user is logged on or not"
+
+On the settings tab
+
+Uncheck "Stop the task if it runs longer than"
+
+Check "Run the task as soon as possible after a scheduled start is missed"
+
+Check "If the task failed, restart every: 10 minutes", and "Attempt to restart up to: 3 times"
+
+Click OK
+
+Start the scheduled task and again check that the agent is connected
+
+Go back to the node’s web page in Jenkins.  If everything works then page should say "Agent is connected"
+
+Installing a Jenkins agent on Windows
+You can install a Jenkins agent on Windows using the command line. In this video, Darin reviews setting up and installing the Jenkins agent, including how to create any necessary files.
+
+How to install a Jenkins agent on Windows
+
+Creating a macOS agent for Jenkins
+This video reviews the process of creating a macOS agent for Jenkins using Java 11.
+
+

data/docs/raw/pipeline_syntax.txt

@@ -0,0 +1,1693 @@
+Pipeline Syntax 
+Table of Contents
+Declarative Pipeline
+Limitations
+Sections
+agent
+post
+stages
+steps
+Directives
+environment
+options
+parameters
+triggers
+Jenkins cron syntax
+stage
+tools
+input
+when
+Sequential Stages
+Parallel
+Matrix
+axes
+stages
+excludes (optional)
+Matrix cell-level directives (optional)
+Steps
+script
+Scripted Pipeline
+Flow Control
+Steps
+Differences from plain Groovy
+Syntax Comparison
+This section builds on the information introduced in Getting started with Pipeline and should be treated solely as a reference. For more information on how to use Pipeline syntax in practical examples, refer to:
+
+Using a Jenkinsfile
+
+Pipeline-as-Code
+
+As of version 2.5 of the Pipeline plugin, Pipeline supports two discrete syntaxes - Declarative and Scripted. For the pros and cons of each, refer to the comparison.
+
+As discussed at the start of this chapter, the most fundamental part of a Pipeline is the "step". Basically, steps tell Jenkins what to do and serve as the basic building block for both Declarative and Scripted Pipeline syntax.
+
+For an overview of available steps, please refer to the Pipeline Steps reference which contains a comprehensive list of steps built into Pipeline as well as steps provided by plugins.
+
+Declarative Pipeline
+Declarative Pipeline presents a more simplified and opinionated syntax on top of the Pipeline sub-systems. In order to use them, install the Pipeline: Declarative Plugin.
+
+All valid Declarative Pipelines must be enclosed within a pipeline block, for example:
+
+pipeline {
+    /* insert Declarative Pipeline here */
+}
+The basic statements and expressions which are valid in Declarative Pipeline follow the same rules as Groovy’s syntax with the following exceptions:
+
+The top-level of the Pipeline must be a block, specifically: pipeline { }.
+
+No semicolons as statement separators. Each statement has to be on its own line.
+
+Blocks must only consist of Sections, Directives, Steps, or assignment statements.
+
+A property reference statement is treated as a no-argument method invocation. So, for example, input is treated as input().
+
+You can use the Declarative Directive Generator to help you get started with configuring the directives and sections in your Declarative Pipeline.
+
+Limitations
+There is currently an open issue which limits the maximum size of the code within the pipeline{} block. This limitation does not apply to Scripted Pipelines.
+
+Sections
+Sections in Declarative Pipeline typically contain one or more Directives or Steps.
+
+agent
+The agent section specifies where the entire Pipeline, or a specific stage, will execute in the Jenkins environment depending on where the agent section is placed. The section must be defined at the top-level inside the pipeline block, but stage-level usage is optional.
+
+Required
+
+Yes
+
+Parameters
+
+Described below
+
+Allowed
+
+In the top-level pipeline block and each stage block.
+
+Differences between top level agents and stage level agents
+There are some nuances when adding an agent to the top level or a stage level when the options directive is applied. Check the section options for more information.
+
+Top Level Agents
+In agents declared at the top level of a Pipeline, an agent is allocated and then the timeout option is applied. The time to allocate the agent is not included in the limit set by the timeout option.
+
+pipeline {
+    agent any
+    options {
+        // Timeout counter starts AFTER agent is allocated
+        timeout(time: 1, unit: 'SECONDS')
+    }
+    stages {
+        stage('Example') {
+            steps {
+                echo 'Hello World'
+            }
+        }
+    }
+}
+Stage Agents
+In agents declared within a stage, the options are invoked before allocating the agent and before checking any when conditions. In this case, when using timeout, it is applied before the agent is allocated. The time to allocate the agent is included in the limit set by the timeout option.
+
+pipeline {
+    agent none
+    stages {
+        stage('Example') {
+            agent any
+            options {
+                // Timeout counter starts BEFORE agent is allocated
+                timeout(time: 1, unit: 'SECONDS')
+            }
+            steps {
+                echo 'Hello World'
+            }
+        }
+    }
+}
+This timeout will include the agent provisioning time. Because the timeout includes the agent provisioning time, the Pipeline may fail in cases where agent allocation is delayed.
+
+Parameters
+In order to support the wide variety of use-cases Pipeline authors may have, the agent section supports a few different types of parameters. These parameters can be applied at the top-level of the pipeline block, or within each stage directive.
+
+any
+Execute the Pipeline, or stage, on any available agent. For example: agent any
+
+none
+When applied at the top-level of the pipeline block no global agent will be allocated for the entire Pipeline run and each stage section will need to contain its own agent section. For example: agent none
+
+label
+Execute the Pipeline, or stage, on an agent available in the Jenkins environment with the provided label. For example: agent { label 'my-defined-label' }
+
+Label conditions can also be used: For example: agent { label 'my-label1 && my-label2' } or agent { label 'my-label1 || my-label2' }
+
+node
+agent { node { label 'labelName' } } behaves the same as agent { label 'labelName' }, but node allows for additional options (such as customWorkspace).
+
+docker
+Execute the Pipeline, or stage, with the given container which will be dynamically provisioned on a node pre-configured to accept Docker-based Pipelines, or on a node matching the optionally defined label parameter. docker also optionally accepts an args parameter which may contain arguments to pass directly to a docker run invocation, and an alwaysPull option, which will force a docker pull even if the image name is already present. For example: agent { docker 'maven:3.9.3-eclipse-temurin-17' } or
+
+agent {
+    docker {
+        image 'maven:3.9.3-eclipse-temurin-17'
+        label 'my-defined-label'
+        args  '-v /tmp:/tmp'
+    }
+}
+docker also optionally accepts a registryUrl and registryCredentialsId parameters which will help to specify the Docker Registry to use and its credentials. The parameter registryCredentialsId could be used alone for private repositories within the docker hub. For example:
+
+agent {
+    docker {
+        image 'myregistry.com/node'
+        label 'my-defined-label'
+        registryUrl 'https://myregistry.com/'
+        registryCredentialsId 'myPredefinedCredentialsInJenkins'
+    }
+}
+dockerfile
+Execute the Pipeline, or stage, with a container built from a Dockerfile contained in the source repository. In order to use this option, the Jenkinsfile must be loaded from either a Multibranch Pipeline or a Pipeline from SCM. Conventionally this is the Dockerfile in the root of the source repository: agent { dockerfile true }. If building a Dockerfile in another directory, use the dir option: agent { dockerfile { dir 'someSubDir' } }. If your Dockerfile has another name, you can specify the file name with the filename option. You can pass additional arguments to the docker build …​ command with the additionalBuildArgs option, like agent { dockerfile { additionalBuildArgs '--build-arg foo=bar' } }. For example, a repository with the file build/Dockerfile.build, expecting a build argument version:
+
+agent {
+    // Equivalent to "docker build -f Dockerfile.build --build-arg version=1.0.2 ./build/
+    dockerfile {
+        filename 'Dockerfile.build'
+        dir 'build'
+        label 'my-defined-label'
+        additionalBuildArgs  '--build-arg version=1.0.2'
+        args '-v /tmp:/tmp'
+    }
+}
+dockerfile also optionally accepts a registryUrl and registryCredentialsId parameters which will help to specify the Docker Registry to use and its credentials. For example:
+
+agent {
+    dockerfile {
+        filename 'Dockerfile.build'
+        dir 'build'
+        label 'my-defined-label'
+        registryUrl 'https://myregistry.com/'
+        registryCredentialsId 'myPredefinedCredentialsInJenkins'
+    }
+}
+kubernetes
+Execute the Pipeline, or stage, inside a pod deployed on a Kubernetes cluster. In order to use this option, the Jenkinsfile must be loaded from either a Multibranch Pipeline or a Pipeline from SCM. The Pod template is defined inside the kubernetes { } block. For example, if you want a pod with a Kaniko container inside it, you would define it as follows:
+
+agent {
+    kubernetes {
+        defaultContainer 'kaniko'
+        yaml '''
+kind: Pod
+spec:
+  containers:
+  - name: kaniko
+    image: gcr.io/kaniko-project/executor:debug
+    imagePullPolicy: Always
+    command:
+    - sleep
+    args:
+    - 99d
+    volumeMounts:
+      - name: aws-secret
+        mountPath: /root/.aws/
+      - name: docker-registry-config
+        mountPath: /kaniko/.docker
+  volumes:
+    - name: aws-secret
+      secret:
+        secretName: aws-secret
+    - name: docker-registry-config
+      configMap:
+        name: docker-registry-config
+'''
+   }
+You will need to create a secret aws-secret for Kaniko to be able to authenticate with ECR. This secret should contain the contents of ~/.aws/credentials. The other volume is a ConfigMap which should contain the endpoint of your ECR registry. For example:
+
+{
+      "credHelpers": {
+        "<your-aws-account-id>.dkr.ecr.eu-central-1.amazonaws.com": "ecr-login"
+      }
+}
+Refer to the following example for reference: https://github.com/jenkinsci/kubernetes-plugin/blob/master/examples/kaniko.groovy
+
+Common Options
+These are a few options that can be applied to two or more agent implementations. They are not required unless explicitly stated.
+
+label
+A string. The label or label condition on which to run the Pipeline or individual stage.
+
+This option is valid for node, docker, and dockerfile, and is required for node.
+
+customWorkspace
+A string. Run the Pipeline or individual stage this agent is applied to within this custom workspace, rather than the default. It can be either a relative path, in which case the custom workspace will be under the workspace root on the node, or an absolute path. For example:
+
+agent {
+    node {
+        label 'my-defined-label'
+        customWorkspace '/some/other/path'
+    }
+}
+This option is valid for node, docker, and dockerfile.
+
+reuseNode
+A boolean, false by default. If true, run the container on the node specified at the top-level of the Pipeline, in the same workspace, rather than on a new node entirely.
+
+This option is valid for docker and dockerfile, and only has an effect when used on an agent for an individual stage.
+
+args
+A string. Runtime arguments to pass to docker run.
+
+This option is valid for docker and dockerfile.
+
+Example 1. Docker Agent, Declarative Pipeline
+pipeline {
+    agent { docker 'maven:3.9.3-eclipse-temurin-17' } 
+    stages {
+        stage('Example Build') {
+            steps {
+                sh 'mvn -B clean verify'
+            }
+        }
+    }
+}
+Execute all the steps defined in this Pipeline within a newly created container of the given name and tag (maven:3.9.3-eclipse-temurin-17).
+Example 2. Stage-level Agent Section
+pipeline {
+    agent none 
+    stages {
+        stage('Example Build') {
+            agent { docker 'maven:3.9.9-eclipse-temurin-21' } 
+            steps {
+                echo 'Hello, Maven'
+                sh 'mvn --version'
+            }
+        }
+        stage('Example Test') {
+            agent { docker 'openjdk:21-jre' } 
+            steps {
+                echo 'Hello, JDK'
+                sh 'java -version'
+            }
+        }
+    }
+}
+Defining agent none at the top-level of the Pipeline ensures that an Executor will not be assigned unnecessarily. Using agent none also forces each stage section to contain its own agent section.
+Execute the steps in this stage in a newly created container using this image.
+Execute the steps in this stage in a newly created container using a different image from the previous stage.
+post
+The post section defines one or more additional steps that are run upon the completion of a Pipeline’s or stage’s run (depending on the location of the post section within the Pipeline). post can support any of the following post-condition blocks: always, changed, fixed, regression, aborted, failure, success, unstable, unsuccessful, and cleanup. These condition blocks allow the execution of steps inside each condition depending on the completion status of the Pipeline or stage. The condition blocks are executed in the order shown below.
+
+Required
+
+No
+
+Parameters
+
+None
+
+Allowed
+
+In the top-level pipeline block and each stage block.
+
+Conditions
+always
+Run the steps in the post section regardless of the completion status of the Pipeline’s or stage’s run.
+
+changed
+Only run the steps in post if the current Pipeline’s run has a different completion status from its previous run.
+
+fixed
+Only run the steps in post if the current Pipeline’s run is successful and the previous run failed or was unstable.
+
+regression
+Only run the steps in post if the current Pipeline’s or status is failure, unstable, or aborted and the previous run was successful.
+
+aborted
+Only run the steps in post if the current Pipeline’s run has an "aborted" status, usually due to the Pipeline being manually aborted. This is typically denoted by gray in the web UI.
+
+failure
+Only run the steps in post if the current Pipeline’s or stage’s run has a "failed" status, typically denoted by red in the web UI.
+
+success
+Only run the steps in post if the current Pipeline’s or stage’s run has a "success" status, typically denoted by blue or green in the web UI.
+
+unstable
+Only run the steps in post if the current Pipeline’s run has an "unstable" status, usually caused by test failures, code violations, etc. This is typically denoted by yellow in the web UI.
+
+unsuccessful
+Only run the steps in post if the current Pipeline’s or stage’s run has not a "success" status. This is typically denoted in the web UI depending on the status previously mentioned (for stages this may fire if the build itself is unstable).
+
+cleanup
+Run the steps in this post condition after every other post condition has been evaluated, regardless of the Pipeline or stage’s status.
+
+Example 3. Post Section, Declarative Pipeline
+pipeline {
+    agent any
+    stages {
+        stage('Example') {
+            steps {
+                echo 'Hello World'
+            }
+        }
+    }
+    post { 
+        always { 
+            echo 'I will always say Hello again!'
+        }
+    }
+}
+Conventionally, the post section should be placed at the end of the Pipeline.
+Post-condition blocks contain steps the same as the steps section.
+stages
+Containing a sequence of one or more stage directives, the stages section is where the bulk of the "work" described by a Pipeline will be located. At a minimum, it is recommended that stages contain at least one stage directive for each discrete part of the continuous delivery process, such as Build, Test, and Deploy.
+
+Required
+
+Yes
+
+Parameters
+
+None
+
+Allowed
+
+Inside the pipeline block, or within a stage.
+
+Example 4. Stages, Declarative Pipeline
+pipeline {
+    agent any
+    stages { 
+        stage('Example') {
+            steps {
+                echo 'Hello World'
+            }
+        }
+    }
+}
+The stages section will typically follow the directives such as agent, options, etc.
+steps
+The steps section defines a series of one or more steps to be executed in a given stage directive.
+
+Required
+
+Yes
+
+Parameters
+
+None
+
+Allowed
+
+Inside each stage block.
+
+Example 5. Single Step, Declarative Pipeline
+pipeline {
+    agent any
+    stages {
+        stage('Example') {
+            steps { 
+                echo 'Hello World'
+            }
+        }
+    }
+}
+The steps section must contain one or more steps.
+Directives
+environment
+The environment directive specifies a sequence of key-value pairs which will be defined as environment variables for all steps, or stage-specific steps, depending on where the environment directive is located within the Pipeline.
+
+This directive supports a special helper method credentials() which can be used to access pre-defined Credentials by their identifier in the Jenkins environment.
+
+Required
+
+No
+
+Parameters
+
+None
+
+Allowed
+
+Inside the pipeline block, or within stage directives.
+
+Supported Credentials Type
+Secret Text
+The environment variable specified will be set to the Secret Text content.
+
+Secret File
+The environment variable specified will be set to the location of the File file that is temporarily created.
+
+Username and password
+The environment variable specified will be set to username:password and two additional environment variables will be automatically defined: MYVARNAME_USR and MYVARNAME_PSW respectively.
+
+SSH with Private Key
+The environment variable specified will be set to the location of the SSH key file that is temporarily created and two additional environment variables will be automatically defined: MYVARNAME_USR and MYVARNAME_PSW (holding the passphrase).
+
+Unsupported credentials type causes the pipeline to fail with the message: org.jenkinsci.plugins.credentialsbinding.impl.CredentialNotFoundException: No suitable binding handler could be found for type <unsupportedType>.
+
+Example 6. Secret Text Credentials, Declarative Pipeline
+pipeline {
+    agent any
+    environment { 
+        CC = 'clang'
+    }
+    stages {
+        stage('Example') {
+            environment { 
+                AN_ACCESS_KEY = credentials('my-predefined-secret-text') 
+            }
+            steps {
+                sh 'printenv'
+            }
+        }
+    }
+}
+An environment directive used in the top-level pipeline block will apply to all steps within the Pipeline.
+An environment directive defined within a stage will only apply the given environment variables to steps within the stage.
+The environment block has a helper method credentials() defined which can be used to access pre-defined Credentials by their identifier in the Jenkins environment.
+Example 7. Username and Password Credentials
+pipeline {
+    agent any
+    stages {
+        stage('Example Username/Password') {
+            environment {
+                SERVICE_CREDS = credentials('my-predefined-username-password')
+            }
+            steps {
+                sh 'echo "Service user is $SERVICE_CREDS_USR"'
+                sh 'echo "Service password is $SERVICE_CREDS_PSW"'
+                sh 'curl -u $SERVICE_CREDS https://myservice.example.com'
+            }
+        }
+        stage('Example SSH Username with private key') {
+            environment {
+                SSH_CREDS = credentials('my-predefined-ssh-creds')
+            }
+            steps {
+                sh 'echo "SSH private key is located at $SSH_CREDS"'
+                sh 'echo "SSH user is $SSH_CREDS_USR"'
+                sh 'echo "SSH passphrase is $SSH_CREDS_PSW"'
+            }
+        }
+    }
+}
+options
+The options directive allows configuring Pipeline-specific options from within the Pipeline itself. Pipeline provides a number of these options, such as buildDiscarder, but they may also be provided by plugins, such as timestamps.
+
+Required
+
+No
+
+Parameters
+
+None
+
+Allowed
+
+Inside the pipeline block, or (with certain limitations) within stage directives.
+
+Available Options
+buildDiscarder
+Persist artifacts and console output for the specific number of recent Pipeline runs. For example: options { buildDiscarder(logRotator(numToKeepStr: '1')) }
+
+checkoutToSubdirectory
+Perform the automatic source control checkout in a subdirectory of the workspace. For example: options { checkoutToSubdirectory('foo') }
+
+disableConcurrentBuilds
+Disallow concurrent executions of the Pipeline. Can be useful for preventing simultaneous accesses to shared resources, etc. For example: options { disableConcurrentBuilds() } to queue a build when there’s already an executing build of the Pipeline, or options { disableConcurrentBuilds(abortPrevious: true) } to abort the running one and start the new build.
+
+disableResume
+Do not allow the pipeline to resume if the controller restarts. For example: options { disableResume() }
+
+newContainerPerStage
+Used with docker or dockerfile top-level agent. When specified, each stage will run in a new container deployed on the same node, rather than all stages running in the same container deployment.
+
+overrideIndexTriggers
+Allows overriding default treatment of branch indexing triggers. If branch indexing triggers are disabled at the multibranch or organization label, options { overrideIndexTriggers(true) } will enable them for this job only. Otherwise, options { overrideIndexTriggers(false) } will disable branch indexing triggers for this job only.
+
+preserveStashes
+Preserve stashes from completed builds, for use with stage restarting. For example: options { preserveStashes() } to preserve the stashes from the most recent completed build, or options { preserveStashes(buildCount: 5) } to preserve the stashes from the five most recent completed builds.
+
+quietPeriod
+Set the quiet period, in seconds, for the Pipeline, overriding the global default. For example: options { quietPeriod(30) }
+
+retry
+On failure, retry the entire Pipeline the specified number of times. For example: options { retry(3) }
+
+skipDefaultCheckout
+Skip checking out code from source control by default in the agent directive. For example: options { skipDefaultCheckout() }
+
+skipStagesAfterUnstable
+Skip stages once the build status has gone to UNSTABLE. For example: options { skipStagesAfterUnstable() }
+
+timeout
+Set a timeout period for the Pipeline run, after which Jenkins should abort the Pipeline. For example: options { timeout(time: 1, unit: 'HOURS') }
+
+Example 8. Global Timeout, Declarative Pipeline
+pipeline {
+    agent any
+    options {
+        timeout(time: 1, unit: 'HOURS') 
+    }
+    stages {
+        stage('Example') {
+            steps {
+                echo 'Hello World'
+            }
+        }
+    }
+}
+Specifying a global execution timeout of one hour, after which Jenkins will abort the Pipeline run.
+timestamps
+Prepend all console output generated by the Pipeline run with the time at which the line was emitted. For example: options { timestamps() }
+
+parallelsAlwaysFailFast
+Set failfast true for all subsequent parallel stages in the pipeline. For example: options { parallelsAlwaysFailFast() }
+
+disableRestartFromStage
+Completely disable option "Restart From Stage" visible in classic Jenkins UI and Blue Ocean as well. For example: options { disableRestartFromStage() }. This option can not be used inside of the stage.
+
+A comprehensive list of available options is pending the completion of help desk ticket 820.
+
+stage options
+The options directive for a stage is similar to the options directive at the root of the Pipeline. However, the stage-level options can only contain steps like retry, timeout, or timestamps, or Declarative options that are relevant to a stage, like skipDefaultCheckout.
+
+Inside a stage, the steps in the options directive are invoked before entering the agent or checking any when conditions.
+
+Available Stage Options
+skipDefaultCheckout
+Skip checking out code from source control by default in the agent directive. For example: options { skipDefaultCheckout() }
+
+timeout
+Set a timeout period for this stage, after which Jenkins should abort the stage. For example: options { timeout(time: 1, unit: 'HOURS') }
+
+Example 9. Stage Timeout, Declarative Pipeline
+pipeline {
+    agent any
+    stages {
+        stage('Example') {
+            options {
+                timeout(time: 1, unit: 'HOURS') 
+            }
+            steps {
+                echo 'Hello World'
+            }
+        }
+    }
+}
+Specifying an execution timeout of one hour for the Example stage, after which Jenkins will abort the Pipeline run.
+retry
+On failure, retry this stage the specified number of times. For example: options { retry(3) }
+
+timestamps
+Prepend all console output generated during this stage with the time at which the line was emitted. For example: options { timestamps() }
+
+parameters
+The parameters directive provides a list of parameters that a user should provide when triggering the Pipeline. The values for these user-specified parameters are made available to Pipeline steps via the params object, refer to the Parameters, Declarative Pipeline for its specific usage.
+
+Each parameter has a Name and Value, depending on the parameter type. This information is exported as environment variables when the build starts, allowing subsequent parts of the build configuration to access those values. For example, use the ${PARAMETER_NAME} syntax with POSIX shells like bash and ksh, the ${Env:PARAMETER_NAME} syntax with PowerShell, or the %PARAMETER_NAME% syntax with Windows cmd.exe.
+
+Required
+
+No
+
+Parameters
+
+None
+
+Allowed
+
+Only once, inside the pipeline block.
+
+Available Parameters
+string
+A parameter of a string type, for example: parameters { string(name: 'DEPLOY_ENV', defaultValue: 'staging', description: '') }.
+
+text
+A text parameter, which can contain multiple lines, for example: parameters { text(name: 'DEPLOY_TEXT', defaultValue: 'One\nTwo\nThree\n', description: '') }.
+
+booleanParam
+A boolean parameter, for example: parameters { booleanParam(name: 'DEBUG_BUILD', defaultValue: true, description: '') }.
+
+choice
+A choice parameter, for example: parameters { choice(name: 'CHOICES', choices: ['one', 'two', 'three'], description: '') }. The first value is the default.
+
+password
+A password parameter, for example: parameters { password(name: 'PASSWORD', defaultValue: 'SECRET', description: 'A secret password') }.
+
+Example 10. Parameters, Declarative Pipeline
+pipeline {
+    agent any
+    parameters {
+        string(name: 'PERSON', defaultValue: 'Mr Jenkins', description: 'Who should I say hello to?')
+
+        text(name: 'BIOGRAPHY', defaultValue: '', description: 'Enter some information about the person')
+
+        booleanParam(name: 'TOGGLE', defaultValue: true, description: 'Toggle this value')
+
+        choice(name: 'CHOICE', choices: ['One', 'Two', 'Three'], description: 'Pick something')
+
+        password(name: 'PASSWORD', defaultValue: 'SECRET', description: 'Enter a password')
+    }
+    stages {
+        stage('Example') {
+            steps {
+                echo "Hello ${params.PERSON}"
+
+                echo "Biography: ${params.BIOGRAPHY}"
+
+                echo "Toggle: ${params.TOGGLE}"
+
+                echo "Choice: ${params.CHOICE}"
+
+                echo "Password: ${params.PASSWORD}"
+            }
+        }
+    }
+}
+A comprehensive list of available parameters is pending the completion of help desk ticket 820.
+
+triggers
+The triggers directive defines the automated ways in which the Pipeline should be re-triggered. For Pipelines which are integrated with a source such as GitHub or BitBucket, triggers may not be necessary as webhooks-based integration will likely already be present. The triggers currently available are cron, pollSCM and upstream.
+
+Required
+
+No
+
+Parameters
+
+None
+
+Allowed
+
+Only once, inside the pipeline block.
+
+cron
+Accepts a cron-style string to define a regular interval at which the Pipeline should be re-triggered, for example: triggers { cron('H */4 * * 1-5') }.
+
+pollSCM
+Accepts a cron-style string to define a regular interval at which Jenkins should check for new source changes. If new changes exist, the Pipeline will be re-triggered. For example: triggers { pollSCM('H */4 * * 1-5') }
+
+upstream
+Accepts a comma-separated string of jobs and a threshold. When any job in the string finishes with the minimum threshold, the Pipeline will be re-triggered. For example: triggers { upstream(upstreamProjects: 'job1,job2', threshold: hudson.model.Result.SUCCESS) }
+
+The pollSCM trigger is only available in Jenkins 2.22 or later.
+
+Example 11. Triggers, Declarative Pipeline
+// Declarative //
+pipeline {
+    agent any
+    triggers {
+        cron('H */4 * * 1-5')
+    }
+    stages {
+        stage('Example') {
+            steps {
+                echo 'Hello World'
+            }
+        }
+    }
+}
+Jenkins cron syntax
+The Jenkins cron syntax follows the syntax of the cron utility (with minor differences). Specifically, each line consists of 5 fields separated by TAB or whitespace:
+
+MINUTE	HOUR	DOM	MONTH	DOW
+Minutes within the hour (0–59)
+
+The hour of the day (0–23)
+
+The day of the month (1–31)
+
+The month (1–12)
+
+The day of the week (0–7) where 0 and 7 are Sunday.
+
+To specify multiple values for one field, the following operators are available. In the order of precedence,
+
+* specifies all valid values
+
+M-N specifies a range of values
+
+M-N/X or */X steps by intervals of X through the specified range or whole valid range
+
+A,B,…​,Z enumerates multiple values
+
+To allow periodically scheduled tasks to produce even load on the system, the symbol H (for “hash”) should be used wherever possible. For example, using 0 0 * * * for a dozen daily jobs will cause a large spike at midnight. In contrast, using H H * * * would still execute each job once a day, but not all at the same time, better using limited resources.
+
+The H symbol can be used with a range. For example, H H(0-7) * * * means some time between 12:00 AM (midnight) to 7:59 AM. You can also use step intervals with H, with or without ranges.
+
+The H symbol can be thought of as a random value over a range, but it actually is a hash of the job name, not a random function, so that the value remains stable for any given project.
+
+Beware that for the day of month field, short cycles such as */3 or H/3 will not work consistently near the end of most months, due to variable month lengths. For example, */3 will run on the 1st, 4th, …31st days of a long month, then again the next day of the next month. Hashes are always chosen in the 1-28 range, so H/3 will produce a gap between runs of between 3 and 6 days at the end of a month. Longer cycles will also have inconsistent lengths, but the effect may be relatively less noticeable.
+
+Empty lines and lines that start with # will be ignored as comments.
+
+In addition, @yearly, @annually, @monthly, @weekly, @daily, @midnight, and @hourly are supported as convenient aliases. These use the hash system for automatic balancing. For example, @hourly is the same as H * * * * and could mean at any time during the hour. @midnight actually means some time between 12:00 AM and 2:59 AM.
+
+Table 1. Jenkins cron syntax examples
+every fifteen minutes (perhaps at :07, :22, :37, :52)
+
+triggers{ cron('H/15 * * * *') }
+
+every ten minutes in the first half of every hour (three times, perhaps at :04, :14, :24)
+
+triggers{ cron('H(0-29)/10 * * * *') }
+
+once every two hours at 45 minutes past the hour starting at 9:45 AM and finishing at 3:45 PM every weekday.
+
+triggers{ cron('45 9-16/2 * * 1-5') }
+
+once in every two hours slot between 9 AM and 5 PM every weekday (perhaps at 10:38 AM, 12:38 PM, 2:38 PM, 4:38 PM)
+
+triggers{ cron('H H(9-16)/2 * * 1-5') }
+
+once a day on the 1st and 15th of every month except December
+
+triggers{ cron('H H 1,15 1-11 *') }
+
+stage
+The stage directive goes in the stages section and should contain a steps section, an optional agent section, or other stage-specific directives. Practically speaking, all of the real work done by a Pipeline will be wrapped in one or more stage directives.
+
+Required
+
+At least one
+
+Parameters
+
+One mandatory parameter, a string for the name of the stage.
+
+Allowed
+
+Inside the stages section.
+
+Example 12. Stage, Declarative Pipeline
+// Declarative //
+pipeline {
+    agent any
+    stages {
+        stage('Example') {
+            steps {
+                echo 'Hello World'
+            }
+        }
+    }
+}
+tools
+A section defining tools to auto-install and put on the PATH. This is ignored if agent none is specified.
+
+Required
+
+No
+
+Parameters
+
+None
+
+Allowed
+
+Inside the pipeline block or a stage block.
+
+Supported Tools
+maven
+jdk
+gradle
+Example 13. Tools, Declarative Pipeline
+pipeline {
+    agent any
+    tools {
+        maven 'apache-maven-3.0.1' 
+    }
+    stages {
+        stage('Example') {
+            steps {
+                sh 'mvn --version'
+            }
+        }
+    }
+}
+The tool name must be pre-configured in Jenkins under Manage Jenkins → Tools.
+input
+The input directive on a stage allows you to prompt for input, using the input step. The stage will pause after any options have been applied, and before entering the agent block for that stage or evaluating the when condition of the stage. If the input is approved, the stage will then continue. Any parameters provided as part of the input submission will be available in the environment for the rest of the stage.
+
+Configuration options
+message
+Required. This will be presented to the user when they go to submit the input.
+
+id
+An optional identifier for this input. The default value is based on the stage name.
+
+ok
+Optional text for the "ok" button on the input form.
+
+submitter
+An optional comma-separated list of users or external group names who are allowed to submit this input. Defaults to allowing any user.
+
+submitterParameter
+An optional name of an environment variable to set with the submitter name, if present.
+
+parameters
+An optional list of parameters to prompt the submitter to provide. Refer to parameters for more information.
+
+Example 14. Input Step, Declarative Pipeline
+pipeline {
+    agent any
+    stages {
+        stage('Example') {
+            input {
+                message "Should we continue?"
+                ok "Yes, we should."
+                submitter "alice,bob"
+                parameters {
+                    string(name: 'PERSON', defaultValue: 'Mr Jenkins', description: 'Who should I say hello to?')
+                }
+            }
+            steps {
+                echo "Hello, ${PERSON}, nice to meet you."
+            }
+        }
+    }
+}
+when
+The when directive allows the Pipeline to determine whether the stage should be executed depending on the given condition. The when directive must contain at least one condition. If the when directive contains more than one condition, all the child conditions must return true for the stage to execute. This is the same as if the child conditions were nested in an allOf condition (refer to the examples below). If an anyOf condition is used, note that the condition skips remaining tests as soon as the first "true" condition is found.
+
+More complex conditional structures can be built using the nesting conditions: not, allOf, or anyOf. Nesting conditions may be nested to any arbitrary depth.
+
+Required
+
+No
+
+Parameters
+
+None
+
+Allowed
+
+Inside a stage directive
+
+Built-in Conditions
+branch
+Execute the stage when the branch being built matches the branch pattern (ANT style path glob) given, for example: when { branch 'master' }. Note that this only works on a multibranch Pipeline.
+
+The optional parameter comparator may be added after an attribute to specify how any patterns are evaluated for a match:
+
+EQUALS for a simple string comparison
+
+GLOB (the default) for an ANT style path glob (same as for example changeset)
+
+REGEXP for regular expression matching
+
+For example: when { branch pattern: "release-\\d+", comparator: "REGEXP"}
+
+buildingTag
+Execute the stage when the build is building a tag. For example: when { buildingTag() }
+
+changelog
+Execute the stage if the build’s SCM changelog contains a given regular expression pattern, for example: when { changelog '.*^\\[DEPENDENCY\\] .+$' }.
+
+changeset
+Execute the stage if the build’s SCM changeset contains one or more files matching the given pattern. Example: when { changeset "**/*.js" }
+
+The optional parameter comparator may be added after an attribute to specify how any patterns are evaluated for a match:
+
+EQUALS for a simple string comparison
+
+GLOB (the default) for an ANT style path glob case insensitive (this can be turned off with the caseSensitive parameter).
+
+REGEXP for regular expression matching
+
+For example: when { changeset pattern: ".TEST\\.java", comparator: "REGEXP" } or when { changeset pattern: "*/*TEST.java", caseSensitive: true }
+
+changeRequest
+Executes the stage if the current build is for a "change request" (a.k.a. Pull Request on GitHub and Bitbucket, Merge Request on GitLab, Change in Gerrit, etc.). When no parameters are passed the stage runs on every change request, for example: when { changeRequest() }.
+
+By adding a filter attribute with parameter to the change request, the stage can be made to run only on matching change requests. Possible attributes are id, target, branch, fork, url, title, author, authorDisplayName, and authorEmail. Each of these corresponds to a CHANGE_* environment variable, for example: when { changeRequest target: 'master' }.
+
+The optional parameter comparator may be added after an attribute to specify how any patterns are evaluated for a match:
+
+EQUALS for a simple string comparison (the default)
+
+GLOB for an ANT style path glob (same as for example changeset)
+
+REGEXP for regular expression matching
+
+Example: when { changeRequest authorEmail: "[\\w_-.]+@example.com", comparator: 'REGEXP' }
+
+environment
+Execute the stage when the specified environment variable is set to the given value, for example: when { environment name: 'DEPLOY_TO', value: 'production' }.
+
+equals
+Execute the stage when the expected value is equal to the actual value, for example: when { equals expected: 2, actual: currentBuild.number }.
+
+expression
+Execute the stage when the specified Groovy expression evaluates to true, for example: when { expression { return params.DEBUG_BUILD } }.
+
+When returning strings from your expressions they must be converted to booleans or return null to evaluate to false. Simply returning "0" or "false" will still evaluate to "true".
+tag
+Execute the stage if the TAG_NAME variable matches the given pattern. For example: when { tag "release-*" } If an empty pattern is provided the stage will execute if the TAG_NAME variable exists (same as buildingTag()).
+
+The optional parameter comparator may be added after an attribute to specify how any patterns are evaluated for a match:
+
+EQUALS for a simple string comparison,
+
+GLOB (the default) for an ANT style path glob (same as for example changeset), or
+
+REGEXP for regular expression matching.
+
+For example: when { tag pattern: "release-\\d+", comparator: "REGEXP"}
+
+not
+Execute the stage when the nested condition is false. Must contain one condition. For example: when { not { branch 'master' } }
+
+allOf
+Execute the stage when all of the nested conditions are true. Must contain at least one condition. For example: when { allOf { branch 'master'; environment name: 'DEPLOY_TO', value: 'production' } }
+
+anyOf
+Execute the stage when at least one of the nested conditions is true. Must contain at least one condition. For example: when { anyOf { branch 'master'; branch 'staging' } }
+
+triggeredBy
+Execute the stage when the current build has been triggered by the param given. For example:
+
+when { triggeredBy 'SCMTrigger' }
+
+when { triggeredBy 'TimerTrigger' }
+
+when { triggeredBy 'BuildUpstreamCause' }
+
+when { triggeredBy cause: "UserIdCause", detail: "vlinde" }
+
+Evaluating when before entering agent in a stage
+By default, the when condition for a stage will be evaluated after entering the agent for that stage, if one is defined. However, this can be changed by specifying the beforeAgent option within the when block. If beforeAgent is set to true, the when condition will be evaluated first, and the agent will only be entered if the when condition evaluates to true.
+
+Evaluating when before the input directive
+By default, the when condition for a stage will not be evaluated before the input, if one is defined. However, this can be changed by specifying the beforeInput option within the when block. If beforeInput is set to true, the when condition will be evaluated first, and the input will only be entered if the when condition evaluates to true.
+
+beforeInput true takes precedence over beforeAgent true.
+
+Evaluating when before the options directive
+By default, the when condition for a stage will be evaluated after entering the options for that stage, if any are defined. However, this can be changed by specifying the beforeOptions option within the when block. If beforeOptions is set to true, the when condition will be evaluated first, and the options will only be entered if the when condition evaluates to true.
+
+beforeOptions true takes precedence over beforeInput true and beforeAgent true.
+
+Example 15. Single Condition, Declarative Pipeline
+pipeline {
+    agent any
+    stages {
+        stage('Example Build') {
+            steps {
+                echo 'Hello World'
+            }
+        }
+        stage('Example Deploy') {
+            when {
+                branch 'production'
+            }
+            steps {
+                echo 'Deploying'
+            }
+        }
+    }
+}
+Example 16. Multiple Condition, Declarative Pipeline
+pipeline {
+    agent any
+    stages {
+        stage('Example Build') {
+            steps {
+                echo 'Hello World'
+            }
+        }
+        stage('Example Deploy') {
+            when {
+                branch 'production'
+                environment name: 'DEPLOY_TO', value: 'production'
+            }
+            steps {
+                echo 'Deploying'
+            }
+        }
+    }
+}
+Example 17. Nested condition (same behavior as previous example)
+pipeline {
+    agent any
+    stages {
+        stage('Example Build') {
+            steps {
+                echo 'Hello World'
+            }
+        }
+        stage('Example Deploy') {
+            when {
+                allOf {
+                    branch 'production'
+                    environment name: 'DEPLOY_TO', value: 'production'
+                }
+            }
+            steps {
+                echo 'Deploying'
+            }
+        }
+    }
+}
+Example 18. Multiple condition and nested condition
+pipeline {
+    agent any
+    stages {
+        stage('Example Build') {
+            steps {
+                echo 'Hello World'
+            }
+        }
+        stage('Example Deploy') {
+            when {
+                branch 'production'
+                anyOf {
+                    environment name: 'DEPLOY_TO', value: 'production'
+                    environment name: 'DEPLOY_TO', value: 'staging'
+                }
+            }
+            steps {
+                echo 'Deploying'
+            }
+        }
+    }
+}
+Example 19. Expression condition and nested condition
+pipeline {
+    agent any
+    stages {
+        stage('Example Build') {
+            steps {
+                echo 'Hello World'
+            }
+        }
+        stage('Example Deploy') {
+            when {
+                expression { BRANCH_NAME ==~ /(production|staging)/ }
+                anyOf {
+                    environment name: 'DEPLOY_TO', value: 'production'
+                    environment name: 'DEPLOY_TO', value: 'staging'
+                }
+            }
+            steps {
+                echo 'Deploying'
+            }
+        }
+    }
+}
+Example 20. beforeAgent
+pipeline {
+    agent none
+    stages {
+        stage('Example Build') {
+            steps {
+                echo 'Hello World'
+            }
+        }
+        stage('Example Deploy') {
+            agent {
+                label "some-label"
+            }
+            when {
+                beforeAgent true
+                branch 'production'
+            }
+            steps {
+                echo 'Deploying'
+            }
+        }
+    }
+}
+Example 21. beforeInput
+pipeline {
+    agent none
+    stages {
+        stage('Example Build') {
+            steps {
+                echo 'Hello World'
+            }
+        }
+        stage('Example Deploy') {
+            when {
+                beforeInput true
+                branch 'production'
+            }
+            input {
+                message "Deploy to production?"
+                id "simple-input"
+            }
+            steps {
+                echo 'Deploying'
+            }
+        }
+    }
+}
+Example 22. beforeOptions
+pipeline {
+    agent none
+    stages {
+        stage('Example Build') {
+            steps {
+                echo 'Hello World'
+            }
+        }
+        stage('Example Deploy') {
+            when {
+                beforeOptions true
+                branch 'testing'
+            }
+            options {
+                lock label: 'testing-deploy-envs', quantity: 1, variable: 'deployEnv'
+            }
+            steps {
+                echo "Deploying to ${deployEnv}"
+            }
+        }
+    }
+}
+Example 23. triggeredBy
+pipeline {
+    agent none
+    stages {
+        stage('Example Build') {
+            steps {
+                echo 'Hello World'
+            }
+        }
+        stage('Example Deploy') {
+            when {
+                triggeredBy "TimerTrigger"
+            }
+            steps {
+                echo 'Deploying'
+            }
+        }
+    }
+}
+Sequential Stages
+Stages in Declarative Pipeline may have a stages section containing a list of nested stages to be run in sequential order.
+
+A stage must have one and only one of steps, stages, parallel, or matrix. It is not possible to nest a parallel or matrix block within a stage directive if that stage directive is nested within a parallel or matrix block itself. However, a stage directive within a parallel or matrix block can use all other functionality of a stage, including agent, tools, when, etc.
+Example 24. Sequential Stages, Declarative Pipeline
+pipeline {
+    agent none
+    stages {
+        stage('Non-Sequential Stage') {
+            agent {
+                label 'for-non-sequential'
+            }
+            steps {
+                echo "On Non-Sequential Stage"
+            }
+        }
+        stage('Sequential') {
+            agent {
+                label 'for-sequential'
+            }
+            environment {
+                FOR_SEQUENTIAL = "some-value"
+            }
+            stages {
+                stage('In Sequential 1') {
+                    steps {
+                        echo "In Sequential 1"
+                    }
+                }
+                stage('In Sequential 2') {
+                    steps {
+                        echo "In Sequential 2"
+                    }
+                }
+                stage('Parallel In Sequential') {
+                    parallel {
+                        stage('In Parallel 1') {
+                            steps {
+                                echo "In Parallel 1"
+                            }
+                        }
+                        stage('In Parallel 2') {
+                            steps {
+                                echo "In Parallel 2"
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+Parallel
+Stages in Declarative Pipeline may have a parallel section containing a list of nested stages to be run in parallel.
+
+A stage must have one and only one of steps, stages, parallel, or matrix. It is not possible to nest a parallel or matrix block within a stage directive if that stage directive is nested within a parallel or matrix block itself. However, a stage directive within a parallel or matrix block can use all other functionality of a stage, including agent, tools, when, etc.
+In addition, you can force your parallel stages to all be aborted when any one of them fails, by adding failFast true to the stage containing the parallel. Another option for adding failfast is adding an option to the pipeline definition: parallelsAlwaysFailFast().
+
+Example 25. Parallel Stages, Declarative Pipeline
+pipeline {
+    agent any
+    stages {
+        stage('Non-Parallel Stage') {
+            steps {
+                echo 'This stage will be executed first.'
+            }
+        }
+        stage('Parallel Stage') {
+            when {
+                branch 'master'
+            }
+            failFast true
+            parallel {
+                stage('Branch A') {
+                    agent {
+                        label "for-branch-a"
+                    }
+                    steps {
+                        echo "On Branch A"
+                    }
+                }
+                stage('Branch B') {
+                    agent {
+                        label "for-branch-b"
+                    }
+                    steps {
+                        echo "On Branch B"
+                    }
+                }
+                stage('Branch C') {
+                    agent {
+                        label "for-branch-c"
+                    }
+                    stages {
+                        stage('Nested 1') {
+                            steps {
+                                echo "In stage Nested 1 within Branch C"
+                            }
+                        }
+                        stage('Nested 2') {
+                            steps {
+                                echo "In stage Nested 2 within Branch C"
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+Example 26. parallelsAlwaysFailFast
+pipeline {
+    agent any
+    options {
+        parallelsAlwaysFailFast()
+    }
+    stages {
+        stage('Non-Parallel Stage') {
+            steps {
+                echo 'This stage will be executed first.'
+            }
+        }
+        stage('Parallel Stage') {
+            when {
+                branch 'master'
+            }
+            parallel {
+                stage('Branch A') {
+                    agent {
+                        label "for-branch-a"
+                    }
+                    steps {
+                        echo "On Branch A"
+                    }
+                }
+                stage('Branch B') {
+                    agent {
+                        label "for-branch-b"
+                    }
+                    steps {
+                        echo "On Branch B"
+                    }
+                }
+                stage('Branch C') {
+                    agent {
+                        label "for-branch-c"
+                    }
+                    stages {
+                        stage('Nested 1') {
+                            steps {
+                                echo "In stage Nested 1 within Branch C"
+                            }
+                        }
+                        stage('Nested 2') {
+                            steps {
+                                echo "In stage Nested 2 within Branch C"
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+Matrix
+Stages in Declarative Pipeline may have a matrix section defining a multi-dimensional matrix of name-value combinations to be run in parallel. We’ll refer these combinations as "cells" in a matrix. Each cell in a matrix can include one or more stages to be run sequentially using the configuration for that cell.
+
+A stage must have one and only one of steps, stages, parallel, or matrix. It is not possible to nest a parallel or matrix block within a stage directive if that stage directive is nested within a parallel or matrix block itself. However, a stage directive within a parallel or matrix block can use all other functionality of a stage, including agent, tools, when, etc.
+In addition, you can force your matrix cells to all be aborted when any one of them fails, by adding failFast true to the stage containing the matrix. Another option for adding failfast is adding an option to the pipeline definition: parallelsAlwaysFailFast().
+
+The matrix section must include an axes section and a stages section. The axes section defines the values for each axis in the matrix. The stages section defines a list of stages to run sequentially in each cell. A matrix may have an excludes section to remove invalid cells from the matrix. Many of the directives available on stage, including agent, tools, when, etc., can also be added to matrix to control the behavior of each cell.
+
+axes
+The axes section specifies one or more axis directives. Each axis consists of a name and a list of values. All the values from each axis are combined with the others to produce the cells.
+
+Example 27. One-axis with 3 cells
+matrix {
+    axes {
+        axis {
+            name 'PLATFORM'
+            values 'linux', 'mac', 'windows'
+        }
+    }
+    // ...
+}
+Example 28. Two-axis with 12 cells (three by four)
+matrix {
+    axes {
+        axis {
+            name 'PLATFORM'
+            values 'linux', 'mac', 'windows'
+        }
+        axis {
+            name 'BROWSER'
+            values 'chrome', 'edge', 'firefox', 'safari'
+        }
+    }
+    // ...
+}
+Example 29. Three-axis matrix with 24 cells (three by four by two)
+matrix {
+    axes {
+        axis {
+            name 'PLATFORM'
+            values 'linux', 'mac', 'windows'
+        }
+        axis {
+            name 'BROWSER'
+            values 'chrome', 'edge', 'firefox', 'safari'
+        }
+        axis {
+            name 'ARCHITECTURE'
+            values '32-bit', '64-bit'
+        }
+    }
+    // ...
+}
+stages
+The stages section specifies one or more stages to be executed sequentially in each cell. This section is identical to any other stages section.
+
+Example 30. One-axis with 3 cells, each cell runs three stages - "build", "test", and "deploy"
+matrix {
+    axes {
+        axis {
+            name 'PLATFORM'
+            values 'linux', 'mac', 'windows'
+        }
+    }
+    stages {
+        stage('build') {
+            // ...
+        }
+        stage('test') {
+            // ...
+        }
+        stage('deploy') {
+            // ...
+        }
+    }
+}
+Example 31. Two-axis with 12 cells (three by four)
+matrix {
+    axes {
+        axis {
+            name 'PLATFORM'
+            values 'linux', 'mac', 'windows'
+        }
+        axis {
+            name 'BROWSER'
+            values 'chrome', 'edge', 'firefox', 'safari'
+        }
+    }
+    stages {
+        stage('build-and-test') {
+            // ...
+        }
+    }
+}
+excludes (optional)
+The optional excludes section lets authors specify one or more exclude filter expressions that select cells to be excluded from the expanded set of matrix cells (aka, sparsening). Filters are constructed using a basic directive structure of one or more of exclude axis directives each with a name and values list.
+
+The axis directives inside an exclude generate a set of combinations (similar to generating the matrix cells). The matrix cells that match all the values from an exclude combination are removed from the matrix. If more than one exclude directive is supplied, each is evaluated separately to remove cells.
+
+When dealing with a long list of values to exclude, exclude axis directives can use notValues instead of values. These will exclude cells that do not match one of the values passed to notValues.
+
+Example 32. Three-axis matrix with 24 cells, exclude '32-bit, mac' (4 cells excluded)
+matrix {
+    axes {
+        axis {
+            name 'PLATFORM'
+            values 'linux', 'mac', 'windows'
+        }
+        axis {
+            name 'BROWSER'
+            values 'chrome', 'edge', 'firefox', 'safari'
+        }
+        axis {
+            name 'ARCHITECTURE'
+            values '32-bit', '64-bit'
+        }
+    }
+    excludes {
+        exclude {
+            axis {
+                name 'PLATFORM'
+                values 'mac'
+            }
+            axis {
+                name 'ARCHITECTURE'
+                values '32-bit'
+            }
+        }
+    }
+    // ...
+}
+Exclude the linux, safari combination and exclude any platform that is not windows with the edge browser.
+
+Example 33. Three-axis matrix with 24 cells, exclude '32-bit, mac' and invalid browser combinations (9 cells excluded)
+matrix {
+    axes {
+        axis {
+            name 'PLATFORM'
+            values 'linux', 'mac', 'windows'
+        }
+        axis {
+            name 'BROWSER'
+            values 'chrome', 'edge', 'firefox', 'safari'
+        }
+        axis {
+            name 'ARCHITECTURE'
+            values '32-bit', '64-bit'
+        }
+    }
+    excludes {
+        exclude {
+            // 4 cells
+            axis {
+                name 'PLATFORM'
+                values 'mac'
+            }
+            axis {
+                name 'ARCHITECTURE'
+                values '32-bit'
+            }
+        }
+        exclude {
+            // 2 cells
+            axis {
+                name 'PLATFORM'
+                values 'linux'
+            }
+            axis {
+                name 'BROWSER'
+                values 'safari'
+            }
+        }
+        exclude {
+            // 3 more cells and '32-bit, mac' (already excluded)
+            axis {
+                name 'PLATFORM'
+                notValues 'windows'
+            }
+            axis {
+                name 'BROWSER'
+                values 'edge'
+            }
+        }
+    }
+    // ...
+}
+Matrix cell-level directives (optional)
+Matrix lets users efficiently configure the overall environment for each cell, by adding stage-level directives under matrix itself. These directives behave the same as they would on a stage but they can also accept values provided by the matrix for each cell.
+
+The axis and exclude directives define the static set of cells that make up the matrix. That set of combinations is generated before the start of the pipeline run. The "per-cell" directives, on the other hand, are evaluated at runtime.
+
+These directives include:
+
+agent
+
+environment
+
+input
+
+options
+
+post
+
+tools
+
+when
+
+Example 34. Complete Matrix Example, Declarative Pipeline
+pipeline {
+    parameters {
+        choice(name: 'PLATFORM_FILTER', choices: ['all', 'linux', 'windows', 'mac'], description: 'Run on specific platform')
+    }
+    agent none
+    stages {
+        stage('BuildAndTest') {
+            matrix {
+                agent {
+                    label "${PLATFORM}-agent"
+                }
+                when { anyOf {
+                    expression { params.PLATFORM_FILTER == 'all' }
+                    expression { params.PLATFORM_FILTER == env.PLATFORM }
+                } }
+                axes {
+                    axis {
+                        name 'PLATFORM'
+                        values 'linux', 'windows', 'mac'
+                    }
+                    axis {
+                        name 'BROWSER'
+                        values 'firefox', 'chrome', 'safari', 'edge'
+                    }
+                }
+                excludes {
+                    exclude {
+                        axis {
+                            name 'PLATFORM'
+                            values 'linux'
+                        }
+                        axis {
+                            name 'BROWSER'
+                            values 'safari'
+                        }
+                    }
+                    exclude {
+                        axis {
+                            name 'PLATFORM'
+                            notValues 'windows'
+                        }
+                        axis {
+                            name 'BROWSER'
+                            values 'edge'
+                        }
+                    }
+                }
+                stages {
+                    stage('Build') {
+                        steps {
+                            echo "Do Build for ${PLATFORM} - ${BROWSER}"
+                        }
+                    }
+                    stage('Test') {
+                        steps {
+                            echo "Do Test for ${PLATFORM} - ${BROWSER}"
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+Steps
+Declarative Pipelines may use all the available steps documented in the Pipeline Steps reference, which contains a comprehensive list of steps, with the addition of the steps listed below which are only supported in Declarative Pipeline.
+
+script
+The script step takes a block of Scripted Pipeline and executes that in the Declarative Pipeline. For most use-cases, the script step should be unnecessary in Declarative Pipelines, but it can provide a useful "escape hatch". script blocks of non-trivial size and/or complexity should be moved into Shared Libraries instead.
+
+Example 35. Script Block in Declarative Pipeline
+pipeline {
+    agent any
+    stages {
+        stage('Example') {
+            steps {
+                echo 'Hello World'
+
+                script {
+                    def browsers = ['chrome', 'firefox']
+                    for (int i = 0; i < browsers.size(); ++i) {
+                        echo "Testing the ${browsers[i]} browser"
+                    }
+                }
+            }
+        }
+    }
+}
+Scripted Pipeline
+Scripted Pipeline, like Declarative Pipeline, is built on top of the underlying Pipeline sub-system. Unlike Declarative, Scripted Pipeline is effectively a general-purpose DSL [1] built with Groovy. Most functionality provided by the Groovy language is made available to users of Scripted Pipeline, which means it can be a very expressive and flexible tool with which one can author continuous delivery pipelines.
+
+Flow Control
+Scripted Pipeline is serially executed from the top of a Jenkinsfile downwards, like most traditional scripts in Groovy or other languages. Providing flow control, therefore, rests on Groovy expressions, such as the if/else conditionals, for example:
+
+Example 36. Conditional Statement if, Scripted Pipeline
+node {
+    stage('Example') {
+        if (env.BRANCH_NAME == 'master') {
+            echo 'I only execute on the master branch'
+        } else {
+            echo 'I execute elsewhere'
+        }
+    }
+}
+Another way Scripted Pipeline flow control can be managed is with Groovy’s exception handling support. When Steps fail for whatever reason they throw an exception. Handling behaviors on-error must make use of the try/catch/finally blocks in Groovy, for example:
+
+Example 37. Try-Catch Block, Scripted Pipeline
+node {
+    stage('Example') {
+        try {
+            sh 'exit 1'
+        }
+        catch (exc) {
+            echo 'Something failed, I should sound the klaxons!'
+            throw
+        }
+    }
+}
+Steps
+As discussed at the start of this chapter, the most fundamental part of a Pipeline is the "step". Fundamentally, steps tell Jenkins what to do and serve as the basic building block for both Declarative and Scripted Pipeline syntax.
+
+Scripted Pipeline does not introduce any steps which are specific to its syntax; Pipeline Steps reference contains a comprehensive list of steps provided by Pipeline and plugins.
+
+Differences from plain Groovy
+In order to provide durability, which means that running Pipelines can survive a restart of the Jenkins controller, Scripted Pipeline must serialize data back to the controller. Due to this design requirement, some Groovy idioms such as collection.each { item → /* perform operation */ } are not fully supported. Refer to JENKINS-27421 and JENKINS-26481 for more information.
+
+Syntax Comparison
+
+This video shares some differences between Scripted and Declarative Pipeline syntax.
+
+When Jenkins Pipeline was first created, Groovy was selected as the foundation. Jenkins has long shipped with an embedded Groovy engine to provide advanced scripting capabilities for admins and users alike. Additionally, the implementors of Jenkins Pipeline found Groovy to be a solid foundation upon which to build what is now referred to as the "Scripted Pipeline" DSL. [1].
+
+As it is a fully-featured programming environment, Scripted Pipeline offers a tremendous amount of flexibility and extensibility to Jenkins users. The Groovy learning-curve isn’t typically desirable for all members of a given team, so Declarative Pipeline was created to offer a simpler and more opinionated syntax for authoring Jenkins Pipeline.
+
+Both are fundamentally the same Pipeline sub-system underneath. They are both durable implementations of "Pipeline as code". They are both able to use steps built into Pipeline or provided by plugins. Both are able to utilize Shared Libraries
+
+Where they differ however is in syntax and flexibility. Declarative limits what is available to the user with a more strict and pre-defined structure, making it an ideal choice for simpler continuous delivery pipelines. Scripted provides very few limits, insofar that the only limits on structure and syntax tend to be defined by Groovy itself, rather than any Pipeline-specific systems, making it an ideal choice for power-users and those with more complex requirements. As the name implies, Declarative Pipeline encourages a declarative programming model. [2] Whereas Scripted Pipelines follow a more imperative programming model. [3]
+
+1. Domain-specific language
+2. Declarative Programming
+3. Imperative Programming   

data/docs/raw/using_a_jenkinsfile.txt

@@ -0,0 +1,810 @@
+Using a Jenkinsfile 
+Table of Contents
+Creating a Jenkinsfile
+Build
+Test
+Deploy
+Working with your Jenkinsfile
+Using environment variables
+Setting environment variables
+Setting environment variables dynamically
+Handling credentials
+For secret text, usernames and passwords, and secret files
+Secret text
+Usernames and passwords
+Secret files
+For other credential types
+Combining credentials in one step
+String interpolation
+Interpolation of sensitive environment variables
+Injection via interpolation
+Handling parameters
+Handling failure
+Error-handling steps
+Using multiple agents
+Optional step arguments
+Advanced Scripted Pipeline
+Parallel execution
+This section builds on the information covered in Getting started with Pipeline and introduces more useful steps, common patterns, and demonstrates some non-trivial Jenkinsfile examples.
+
+Creating a Jenkinsfile, which is checked into source control [1], provides a number of immediate benefits:
+
+Code review/iteration on the Pipeline
+
+Audit trail for the Pipeline
+
+Single source of truth [2] for the Pipeline, which can be viewed and edited by multiple members of the project.
+
+Pipeline supports two syntaxes, Declarative (introduced in Pipeline 2.5) and Scripted Pipeline. Both of which support building continuous delivery pipelines. Both may be used to define a Pipeline in either the web UI or with a Jenkinsfile, though it’s generally considered a best practice to create a Jenkinsfile and check the file into the source control repository.
+
+Creating a Jenkinsfile
+As discussed in the Defining a Pipeline in SCM, a Jenkinsfile is a text file that contains the definition of a Jenkins Pipeline and is checked into source control. Consider the following Pipeline which implements a basic three-stage continuous delivery pipeline.
+
+Jenkinsfile (Declarative Pipeline)
+pipeline {
+    agent any
+
+    stages {
+        stage('Build') {
+            steps {
+                echo 'Building..'
+            }
+        }
+        stage('Test') {
+            steps {
+                echo 'Testing..'
+            }
+        }
+        stage('Deploy') {
+            steps {
+                echo 'Deploying....'
+            }
+        }
+    }
+}
+Toggle Scripted Pipeline (Advanced)
+Not all Pipelines will have these same three stages, but it is a good starting point to define them for most projects. The sections below will demonstrate the creation and execution of a simple Pipeline in a test installation of Jenkins.
+
+It is assumed that there is already a source control repository set up for the project and a Pipeline has been defined in Jenkins following these instructions.
+
+Using a text editor, ideally one which supports Groovy syntax highlighting, create a new Jenkinsfile in the root directory of the project.
+
+The Declarative Pipeline example above contains the minimum necessary structure to implement a continuous delivery pipeline. The agent directive, which is required, instructs Jenkins to allocate an executor and workspace for the Pipeline. Without an agent directive, not only is the Declarative Pipeline not valid, it would not be capable of doing any work! By default the agent directive ensures that the source repository is checked out and made available for steps in the subsequent stages.
+
+The stages directive and steps directives are also required for a valid Declarative Pipeline as they instruct Jenkins what to execute and in which stage it should be executed.
+
+For more advanced usage with Scripted Pipeline, the example above node is a crucial first step as it allocates an executor and workspace for the Pipeline. In essence, without node, a Pipeline cannot do any work! From within node, the first order of business will be to checkout the source code for this project. Since the Jenkinsfile is being pulled directly from source control, Pipeline provides a quick and easy way to access the right revision of the source code.
+
+Jenkinsfile (Scripted Pipeline)
+node {
+    checkout scm 
+    /* .. snip .. */
+}
+The checkout step will checkout code from source control; scm is a special variable which instructs the checkout step to clone the specific revision which triggered this Pipeline run.
+Build
+For many projects the beginning of "work" in the Pipeline would be the "build" stage. Typically this stage of the Pipeline will be where source code is assembled, compiled, or packaged. The Jenkinsfile is not a replacement for an existing build tool such as GNU/Make, Maven, Gradle, or others, but rather can be viewed as a glue layer to bind the multiple phases of a project’s development lifecycle (build, test, deploy) together.
+
+Jenkins has a number of plugins for invoking practically any build tool in general use, but this example will simply invoke make from a shell step (sh). The sh step assumes the system is Unix/Linux-based, for Windows-based systems the bat could be used instead.
+
+Jenkinsfile (Declarative Pipeline)
+pipeline {
+    agent any
+
+    stages {
+        stage('Build') {
+            steps {
+                sh 'make' 
+                archiveArtifacts artifacts: '**/target/*.jar', fingerprint: true 
+            }
+        }
+    }
+}
+Toggle Scripted Pipeline (Advanced)
+The sh step invokes the make command and will only continue if a zero exit code is returned by the command. Any non-zero exit code will fail the Pipeline.
+archiveArtifacts captures the files built matching the include pattern (**/target/*.jar) and saves them to the Jenkins controller for later retrieval.
+Archiving artifacts is not a substitute for using external artifact repositories such as Artifactory or Nexus and should be considered only for basic reporting and file archival.
+
+Test
+Running automated tests is a crucial component of any successful continuous delivery process. As such, Jenkins has a number of test recording, reporting, and visualization facilities provided by a number of plugins. At a fundamental level, when there are test failures, it is useful to have Jenkins record the failures for reporting and visualization in the web UI. The example below uses the junit step, provided by the JUnit plugin.
+
+In the example below, if tests fail, the Pipeline is marked "unstable", as denoted by a yellow ball in the web UI. Based on the recorded test reports, Jenkins can also provide historical trend analysis and visualization.
+
+Jenkinsfile (Declarative Pipeline)
+pipeline {
+    agent any
+
+    stages {
+        stage('Test') {
+            steps {
+                /* `make check` returns non-zero on test failures,
+                * using `true` to allow the Pipeline to continue nonetheless
+                */
+                sh 'make check || true' 
+                junit '**/target/*.xml' 
+            }
+        }
+    }
+}
+Toggle Scripted Pipeline (Advanced)
+Using an inline shell conditional (sh 'make check || true') ensures that the sh step always sees a zero exit code, giving the junit step the opportunity to capture and process the test reports. Alternative approaches to this are covered in more detail in the Handling failure section below.
+junit captures and associates the JUnit XML files matching the inclusion pattern (**/target/*.xml).
+Deploy
+Deployment can imply a variety of steps, depending on the project or organization requirements, and may be anything from publishing built artifacts to an Artifactory server, to pushing code to a production system.
+
+At this stage of the example Pipeline, both the "Build" and "Test" stages have successfully executed. In essence, the "Deploy" stage will only execute assuming previous stages completed successfully, otherwise the Pipeline would have exited early.
+
+Jenkinsfile (Declarative Pipeline)
+pipeline {
+    agent any
+
+    stages {
+        stage('Deploy') {
+            when {
+              expression {
+                currentBuild.result == null || currentBuild.result == 'SUCCESS' 
+              }
+            }
+            steps {
+                sh 'make publish'
+            }
+        }
+    }
+}
+Toggle Scripted Pipeline (Advanced)
+Accessing the currentBuild.result variable allows the Pipeline to determine if there were any test failures. In which case, the value would be UNSTABLE.
+Assuming everything has executed successfully in the example Jenkins Pipeline, each successful Pipeline run will have associated build artifacts archived, test results reported upon and the full console output all in Jenkins.
+
+A Scripted Pipeline can include conditional tests (shown above), loops, try/catch/finally blocks, and even functions. The next section will cover this advanced Scripted Pipeline syntax in more detail.
+
+Working with your Jenkinsfile
+The following sections provide details about handling:
+
+specific Pipeline syntax in your Jenkinsfile and
+
+features and functionality of Pipeline syntax which are essential in building your application or Pipeline project.
+
+Using environment variables
+Jenkins Pipeline exposes environment variables via the global variable env, which is available from anywhere within a Jenkinsfile. The full list of environment variables accessible from within Jenkins Pipeline is documented at ${YOUR_JENKINS_URL}/pipeline-syntax/globals#env and includes:
+
+BUILD_ID
+The current build ID, identical to BUILD_NUMBER for builds created in Jenkins versions 1.597+.
+
+BUILD_NUMBER
+The current build number, such as "153".
+
+BUILD_TAG
+String of jenkins-${JOB_NAME}-${BUILD_NUMBER}. Convenient to put into a resource file, a jar file, etc for easier identification.
+
+BUILD_URL
+The URL where the results of this build can be found (for example, http://buildserver/jenkins/job/MyJobName/17/).
+
+EXECUTOR_NUMBER
+The unique number that identifies the current executor (among executors of the same machine) performing this build. This is the number you see in the "build executor status", except that the number starts from 0, not 1.
+
+JAVA_HOME
+If your job is configured to use a specific JDK, this variable is set to the JAVA_HOME of the specified JDK. When this variable is set, PATH is also updated to include the bin subdirectory of JAVA_HOME.
+
+JENKINS_URL
+Full URL of Jenkins, such as https://example.com:port/jenkins/ (NOTE: only available if Jenkins URL set in "System Configuration").
+
+JOB_NAME
+Name of the project of this build, such as "foo" or "foo/bar".
+
+NODE_NAME
+The name of the node the current build is running on. Set to 'master' for the Jenkins controller.
+
+WORKSPACE
+The absolute path of the workspace.
+
+Referencing or using these environment variables can be accomplished like accessing any key in a Groovy Map, for example:
+
+Jenkinsfile (Declarative Pipeline)
+pipeline {
+    agent any
+    stages {
+        stage('Example') {
+            steps {
+                echo "Running ${env.BUILD_ID} on ${env.JENKINS_URL}"
+            }
+        }
+    }
+}
+Toggle Scripted Pipeline (Advanced)
+Setting environment variables
+Setting an environment variable within a Jenkins Pipeline is accomplished differently depending on whether Declarative or Scripted Pipeline is used.
+
+Declarative Pipeline supports an environment directive, whereas users of Scripted Pipeline must use the withEnv step.
+
+Jenkinsfile (Declarative Pipeline)
+pipeline {
+    agent any
+    environment { 
+        CC = 'clang'
+    }
+    stages {
+        stage('Example') {
+            environment { 
+                DEBUG_FLAGS = '-g'
+            }
+            steps {
+                sh 'printenv'
+            }
+        }
+    }
+}
+Toggle Scripted Pipeline (Advanced)
+An environment directive used in the top-level pipeline block will apply to all steps within the Pipeline.
+An environment directive defined within a stage will only apply the given environment variables to steps within the stage.
+Setting environment variables dynamically
+Environment variables can be set at run time and can be used by shell scripts (sh), Windows batch scripts (bat) and PowerShell scripts (powershell). Each script can either returnStatus or returnStdout. More information on scripts.
+
+Below is an example in a declarative pipeline using sh (shell) with both returnStatus and returnStdout.
+
+Jenkinsfile (Declarative Pipeline)
+pipeline {
+    agent any 
+    environment {
+        // Using returnStdout
+        CC = """${sh(
+                returnStdout: true,
+                script: 'echo "clang"'
+            )}""" 
+        // Using returnStatus
+        EXIT_STATUS = """${sh(
+                returnStatus: true,
+                script: 'exit 1'
+            )}"""
+    }
+    stages {
+        stage('Example') {
+            environment {
+                DEBUG_FLAGS = '-g'
+            }
+            steps {
+                sh 'printenv'
+            }
+        }
+    }
+}
+An agent must be set at the top level of the pipeline. This will fail if agent is set as agent none.
+When using returnStdout a trailing whitespace will be appended to the returned string. Use .trim() to remove this.
+Handling credentials
+Credentials configured in Jenkins can be handled in Pipelines for immediate use. Read more about using credentials in Jenkins on the Using credentials page.
+
+The correct way to handle credentials in Jenkins
+
+For secret text, usernames and passwords, and secret files
+Jenkins' declarative Pipeline syntax has the credentials() helper method (used within the environment directive) which supports secret text, username and password, as well as secret file credentials. If you want to handle other types of credentials, refer to the For other credential types section.
+
+Secret text
+The following Pipeline code shows an example of how to create a Pipeline using environment variables for secret text credentials.
+
+In this example, two secret text credentials are assigned to separate environment variables to access Amazon Web Services (AWS). These credentials would have been configured in Jenkins with their respective credential IDs jenkins-aws-secret-key-id and jenkins-aws-secret-access-key.
+
+Jenkinsfile (Declarative Pipeline)
+pipeline {
+    agent {
+        // Define agent details here
+    }
+    environment {
+        AWS_ACCESS_KEY_ID     = credentials('jenkins-aws-secret-key-id')
+        AWS_SECRET_ACCESS_KEY = credentials('jenkins-aws-secret-access-key')
+    }
+    stages {
+        stage('Example stage 1') {
+            steps {
+                // 
+            }
+        }
+        stage('Example stage 2') {
+            steps {
+                // 
+            }
+        }
+    }
+}
+You can reference the two credential environment variables (defined in this Pipeline’s environment directive), within this stage’s steps using the syntax $AWS_ACCESS_KEY_ID and $AWS_SECRET_ACCESS_KEY. For example, here you can authenticate to AWS using the secret text credentials assigned to these credential variables. To maintain the security and anonymity of these credentials, if the job displays the value of these credential variables from within the Pipeline (such as echo $AWS_SECRET_ACCESS_KEY), Jenkins only returns the value “****” to reduce the risk of secret information being disclosed to the console output and any logs. Any sensitive information in credential IDs themselves (such as usernames) are also returned as “****” in the Pipeline run’s output. This only reduces the risk of accidental exposure. It does not prevent a malicious user from capturing the credential value by other means. A Pipeline that uses credentials can also disclose those credentials. Don’t allow untrusted Pipeline jobs to use trusted credentials.
+In this Pipeline example, the credentials assigned to the two AWS_…​ environment variables are scoped globally for the entire Pipeline, so these credential variables could also be used in this stage’s steps. If, however, the environment directive in this Pipeline were moved to a specific stage (as is the case in the Usernames and passwords Pipeline example below), then these AWS_…​ environment variables would only be scoped to the steps in that stage.
+Storing static AWS keys in Jenkins credentials is not very secure. If you can run Jenkins itself in AWS (at least the agent), it is preferable to use IAM roles for a computer or EKS service account. It is also possible to use web identity federation.
+Usernames and passwords
+The following Pipeline code snippets show an example of how to create a Pipeline using environment variables for username and password credentials.
+
+In this example, username and password credentials are assigned to environment variables to access a Bitbucket repository in a common account or team for your organization; these credentials would have been configured in Jenkins with the credential ID jenkins-bitbucket-common-creds.
+
+When setting the credential environment variable in the environment directive:
+
+environment {
+    BITBUCKET_COMMON_CREDS = credentials('jenkins-bitbucket-common-creds')
+}
+this actually sets the following three environment variables:
+
+BITBUCKET_COMMON_CREDS - contains a username and a password separated by a colon in the format username:password.
+
+BITBUCKET_COMMON_CREDS_USR - an additional variable containing the username component only.
+
+BITBUCKET_COMMON_CREDS_PSW - an additional variable containing the password component only.
+
+By convention, variable names for environment variables are typically specified in capital case, with individual words separated by underscores You can, however, specify any legitimate variable name using lower case characters. Bear in mind that the additional environment variables created by the credentials() method (above) will always be appended with _USR and _PSW (i.e. in the format of an underscore followed by three capital letters).
+
+The following code snippet shows the example Pipeline in its entirety:
+
+Jenkinsfile (Declarative Pipeline)
+pipeline {
+    agent {
+        // Define agent details here
+    }
+    stages {
+        stage('Example stage 1') {
+            environment {
+                BITBUCKET_COMMON_CREDS = credentials('jenkins-bitbucket-common-creds')
+            }
+            steps {
+                // 
+            }
+        }
+        stage('Example stage 2') {
+            steps {
+                // 
+            }
+        }
+    }
+}
+The following credential environment variables (defined in this Pipeline’s environment directive) are available within this stage’s steps and can be referenced using the syntax:
+$BITBUCKET_COMMON_CREDS
+
+$BITBUCKET_COMMON_CREDS_USR
+
+$BITBUCKET_COMMON_CREDS_PSW
+
+For example, here you can authenticate to Bitbucket with the username and password assigned to these credential variables. To maintain the security and anonymity of these credentials, if the job displays the value of these credential variables from within the Pipeline the same behavior described in the Secret text example above applies to these username and password credential variable types too. This only reduces the risk of accidental exposure. It does not prevent a malicious user from capturing the credential value by other means. A Pipeline that uses credentials can also disclose those credentials. Don’t allow untrusted Pipeline jobs to use trusted credentials.
+
+In this Pipeline example, the credentials assigned to the three BITBUCKET_COMMON_CREDS…​ environment variables are scoped only to Example stage 1, so these credential variables are not available for use in this Example stage 2 stage’s steps. If, however, the environment directive in this Pipeline were moved immediately within the pipeline block (as is the case in the Secret text Pipeline example above), then these BITBUCKET_COMMON_CREDS…​ environment variables would be scoped globally and could be used in any stage’s steps.
+Secret files
+A secret file is a credential which is stored in a file and uploaded to Jenkins. Secret files are used for credentials that are:
+
+too unwieldy to enter directly into Jenkins, and/or
+
+in binary format, such as a GPG file.
+
+In this example, we use a Kubernetes config file that has been configured as a secret file credential named my-kubeconfig.
+
+Jenkinsfile (Declarative Pipeline)
+pipeline {
+    agent {
+        // Define agent details here
+    }
+    environment {
+        // The MY_KUBECONFIG environment variable will be assigned the value of a temporary file.
+        // For example:
+        //   /home/user/.jenkins/workspace/cred_test@tmp/secretFiles/546a5cf3-9b56-4165-a0fd-19e2afe6b31f/kubeconfig.txt
+        MY_KUBECONFIG = credentials('my-kubeconfig')
+    }
+    stages {
+        stage('Example stage 1') {
+            steps {
+                sh("kubectl --kubeconfig $MY_KUBECONFIG get pods")
+            }
+        }
+    }
+}
+For other credential types
+If you need to set credentials in a Pipeline for anything other than secret text, usernames and passwords, or secret files like SSH keys or certificates, use Jenkins' Snippet Generator feature, which you can access through Jenkins' classic UI.
+
+To access the Snippet Generator for your Pipeline project/item:
+
+From the Jenkins Dashboard, select the name of your Pipeline project/item.
+
+In the left navigation pane, select Pipeline Syntax and ensure that the Snippet Generator option is available at the top of the navigation pane.
+
+From the Sample Step field, choose withCredentials: Bind credentials to variables.
+
+Under Bindings, click Add and choose from the dropdown:
+
+SSH User Private Key - to handle SSH public/private key pair credentials, from which you can specify:
+
+Key File Variable - the name of the environment variable that will be bound to these credentials. Jenkins actually assigns this temporary variable to the secure location of the private key file required in the SSH public/private key pair authentication process.
+
+Passphrase Variable ( Optional ) - the name of the environment variable that will be bound to the passphrase associated with the SSH public/private key pair.
+
+Username Variable ( Optional ) - the name of the environment variable that will be bound to username associated with the SSH public/private key pair.
+
+Credentials - choose the SSH public/private key credentials stored in Jenkins. The value of this field is the credential ID, which Jenkins writes out to the generated snippet.
+
+Certificate - to handle PKCS#12 certificates, from which you can specify:
+
+Keystore Variable - the name of the environment variable that will be bound to these credentials. Jenkins actually assigns this temporary variable to the secure location of the certificate’s keystore required in the certificate authentication process.
+
+Password Variable ( Optional ) - the name of the environment variable that will be bound to the password associated with the certificate.
+
+Alias Variable ( Optional ) - the name of the environment variable that will be bound to the unique alias associated with the certificate.
+
+Credentials - choose the certificate credentials stored in Jenkins. The value of this field is the credential ID, which Jenkins writes out to the generated snippet.
+
+Docker client certificate - to handle Docker Host Certificate Authentication.
+
+Click Generate Pipeline Script and Jenkins generates a withCredentials(…​) { …​ } Pipeline step snippet for the credentials you specified, which you can then copy and paste into your Declarative or Scripted Pipeline code.
+Notes:
+
+The Credentials fields (above) show the names of credentials configured in Jenkins. However, these values are converted to credential IDs after clicking Generate Pipeline Script.
+
+To combine more than one credential in a single withCredentials(…​) { …​ } Pipeline step, see Combining credentials in one step (below) for details.
+
+SSH User Private Key example
+
+withCredentials(bindings: [sshUserPrivateKey(credentialsId: 'jenkins-ssh-key-for-abc', \
+                                             keyFileVariable: 'SSH_KEY_FOR_ABC', \
+                                             passphraseVariable: '', \
+                                             usernameVariable: '')]) {
+  // some block
+}
+The optional passphraseVariable and usernameVariable definitions can be deleted in your final Pipeline code.
+
+Certificate example
+
+withCredentials(bindings: [certificate(aliasVariable: '', \
+                                       credentialsId: 'jenkins-certificate-for-xyz', \
+                                       keystoreVariable: 'CERTIFICATE_FOR_XYZ', \
+                                       passwordVariable: 'XYZ-CERTIFICATE-PASSWORD')]) {
+  // some block
+}
+The optional aliasVariable and passwordVariable variable definitions can be deleted in your final Pipeline code.
+
+The following code snippet shows an example Pipeline in its entirety, which implements the SSH User Private Key and Certificate snippets above:
+
+Jenkinsfile (Declarative Pipeline)
+pipeline {
+    agent {
+        // define agent details
+    }
+    stages {
+        stage('Example stage 1') {
+            steps {
+                withCredentials(bindings: [sshUserPrivateKey(credentialsId: 'jenkins-ssh-key-for-abc', \
+                                                             keyFileVariable: 'SSH_KEY_FOR_ABC')]) {
+                  // 
+                }
+                withCredentials(bindings: [certificate(credentialsId: 'jenkins-certificate-for-xyz', \
+                                                       keystoreVariable: 'CERTIFICATE_FOR_XYZ', \
+                                                       passwordVariable: 'XYZ-CERTIFICATE-PASSWORD')]) {
+                  // 
+                }
+            }
+        }
+        stage('Example stage 2') {
+            steps {
+                // 
+            }
+        }
+    }
+}
+Within this step, you can reference the credential environment variable with the syntax $SSH_KEY_FOR_ABC. For example, here you can authenticate to the ABC application with its configured SSH public/private key pair credentials, whose SSH User Private Key file is assigned to $SSH_KEY_FOR_ABC.
+Within this step, you can reference the credential environment variable with the syntax $CERTIFICATE_FOR_XYZ and $XYZ-CERTIFICATE-PASSWORD. For example, here you can authenticate to the XYZ application with its configured certificate credentials, whose Certificate's keystore file and password are assigned to the variables $CERTIFICATE_FOR_XYZ and $XYZ-CERTIFICATE-PASSWORD, respectively.
+In this Pipeline example, the credentials assigned to the $SSH_KEY_FOR_ABC, $CERTIFICATE_FOR_XYZ and $XYZ-CERTIFICATE-PASSWORD environment variables are scoped only within their respective withCredentials( …​ ) { …​ } steps, so these credential variables are not available for use in this Example stage 2 stage’s steps.
+To maintain the security and anonymity of these credentials, if you attempt to retrieve the value of these credential variables from within these withCredentials( …​ ) { …​ } steps, the same behavior described in the Secret text example (above) applies to these SSH public/private key pair credential and certificate variable types too. This only reduces the risk of accidental exposure. It does not prevent a malicious user from capturing the credential value by other means. A Pipeline that uses credentials can also disclose those credentials. Don’t allow untrusted Pipeline jobs to use trusted credentials.
+
+When using the Sample Step field’s withCredentials: Bind credentials to variables option in the Snippet Generator, only credentials which your current Pipeline project/item has access to can be selected from any Credentials field’s list. While you can manually write a withCredentials( …​ ) { …​ } step for your Pipeline (like the examples above), using the Snippet Generator is recommended to avoid specifying credentials that are out of scope for this Pipeline project/item, which when run, will make the step fail.
+
+You can also use the Snippet Generator to generate withCredentials( …​ ) { …​ } steps to handle secret text, usernames and passwords and secret files. However, if you only need to handle these types of credentials, it is recommended you use the relevant procedure described in the section above for improved Pipeline code readability.
+
+The use of single-quotes instead of double-quotes to define the script (the implicit parameter to sh) in Groovy above. The single-quotes will cause the secret to be expanded by the shell as an environment variable. The double-quotes are potentially less secure as the secret is interpolated by Groovy, and so typical operating system process listings will accidentally disclose it :
+
+node {
+  withCredentials([string(credentialsId: 'mytoken', variable: 'TOKEN')]) {
+    sh /* WRONG! */ """
+      set +x
+      curl -H 'Token: $TOKEN' https://some.api/
+    """
+    sh /* CORRECT */ '''
+      set +x
+      curl -H 'Token: $TOKEN' https://some.api/
+    '''
+  }
+}
+Combining credentials in one step
+Using the Snippet Generator, you can make multiple credentials available within a single withCredentials( …​ ) { …​ } step by doing the following:
+
+From the Jenkins Dashboard, select the name of your Pipeline project/item.
+
+In the left navigation pane, select Pipeline Syntax and ensure that the Snippet Generator option is available at the top of the navigation pane.
+
+From the Sample Step field, choose withCredentials: Bind credentials to variables.
+
+Click Add under Bindings.
+
+Choose the credential type to add to the withCredentials( …​ ) { …​ } step from the dropdown list.
+
+Specify the credential Bindings details. Read more above these in the procedure under For other credential types (above).
+
+Repeat from "Click Add …​" (above) for each (set of) credential/s to add to the withCredentials( …​ ) { …​ } step.
+
+Select Generate Pipeline Script to generate the final withCredentials( …​ ) { …​ } step snippet.
+
+String interpolation
+Jenkins Pipeline uses rules identical to Groovy for string interpolation. Groovy’s String interpolation support can be confusing to many newcomers to the language. While Groovy supports declaring a string with either single quotes, or double quotes, for example:
+
+def singlyQuoted = 'Hello'
+def doublyQuoted = "World"
+Only the latter string will support the dollar-sign ($) based string interpolation, for example:
+
+def username = 'Jenkins'
+echo 'Hello Mr. ${username}'
+echo "I said, Hello Mr. ${username}"
+Would result in:
+
+Hello Mr. ${username}
+I said, Hello Mr. Jenkins
+Understanding how to use string interpolation is vital for using some of Pipeline’s more advanced features.
+
+Interpolation of sensitive environment variables
+Groovy string interpolation should never be used with credentials.
+
+Groovy GStrings (double-quoted or triple-double-quoted strings) expand ${TOKEN} before the command is sent to the agent. When that happens, the secret is copied into the process arguments (visible via tooling such as ps) and any shell metacharacters inside the secret or user-controlled value are executed immediately. Always send a literal command string to sh, bat, powershell, or pwsh and let the shell read secrets from its environment, which withCredentials or the environment block have already populated.
+
+Jenkinsfile (Declarative Pipeline)
+pipeline {
+    agent any
+    environment {
+        API_TOKEN = credentials('example-token-id')
+    }
+    stages {
+        stage('Example') {
+            steps {
+                /* WRONG */
+                    sh "curl -H 'Authorization: Bearer ${API_TOKEN}' https://example.com"
+                """
+            }
+        }
+    }
+}
+Jenkinsfile (Declarative Pipeline)
+pipeline {
+    agent any
+    environment {
+        API_TOKEN = credentials('example-token-id')
+    }
+    stages {
+        stage('Example') {
+            steps {
+                /* CORRECT */
+                sh 'curl -H "Authorization: Bearer ${API_TOKEN}" https://example.com'
+            }
+        }
+    }
+}
+Any Groovy construct that avoids interpolation (for example, sh(script: 'curl …​ $API_TOKEN', label: 'call API')) is safe; the key is keeping secrets out of GStrings so only the shell expands them.
+
+Injection via interpolation
+Groovy string interpolation can inject rogue commands into command interpreters via special characters.
+
+Another note of caution. Using Groovy string interpolation for user-controlled variables with steps that pass their arguments to command interpreters such as the sh, bat, powershell, or pwsh steps can result in problems analogous to SQL injection. This occurs when a user-controlled variable (generally an environment variable, usually a parameter passed to the build) that contains special characters (e.g. / \ $ & % ^ > < | ;) is passed to the sh, bat, powershell, or pwsh steps using Groovy interpolation. For a simple example:
+
+Jenkinsfile (Declarative Pipeline)
+pipeline {
+  agent any
+  parameters {
+    string(name: 'STATEMENT', defaultValue: 'hello; ls /', description: 'What should I say?')
+  }
+  stages {
+    stage('Example') {
+      steps {
+        /* WRONG! */
+        sh("echo ${STATEMENT}")
+      }
+    }
+  }
+}
+In this example, the argument to the sh step is evaluated by Groovy, and STATEMENT is interpolated directly into the argument as if sh('echo hello; ls /') has been written in the Pipeline. When this is processed on the agent, rather than echoing the value hello; ls /, it will echo hello then proceed to list the entire root directory of the agent. Any user able to control a variable interpolated by such a step would be able to make the sh step run arbitrary code on the agent. To avoid this problem, make sure arguments to steps such as sh or bat that reference parameters or other user-controlled environment variables use single quotes to avoid Groovy interpolation.
+
+Jenkinsfile (Declarative Pipeline)
+pipeline {
+  agent any
+  parameters {
+    string(name: 'STATEMENT', defaultValue: 'hello; ls /', description: 'What should I say?')
+  }
+  stages {
+    stage('Example') {
+      steps {
+        /* CORRECT */
+        sh('echo ${STATEMENT}')
+      }
+    }
+  }
+}
+Credential mangling is another issue that can occur when credentials that contain special characters are passed to a step using Groovy interpolation. When the credential value is mangled, it is no longer valid and will no longer be masked in the console log.
+
+Jenkinsfile (Declarative Pipeline)
+pipeline {
+  agent any
+  environment {
+    EXAMPLE_KEY = credentials('example-credentials-id') // Secret value is 'sec%ret'
+  }
+  stages {
+    stage('Example') {
+      steps {
+          /* WRONG! */
+          bat "echo ${EXAMPLE_KEY}"
+      }
+    }
+  }
+}
+Here, the bat step receives echo sec%ret and the Windows batch shell will simply drop the % and print out the value secret. Because there is a single character difference, the value secret will not be masked. Though the value is not the same as the actual credential, this is still a significant exposure of sensitive information. Again, single-quotes avoids this issue.
+
+Jenkinsfile (Declarative Pipeline)
+pipeline {
+  agent any
+  environment {
+    EXAMPLE_KEY = credentials('example-credentials-id') // Secret value is 'sec%ret'
+  }
+  stages {
+    stage('Example') {
+      steps {
+          /* CORRECT */
+          bat 'echo %EXAMPLE_KEY%'
+      }
+    }
+  }
+}
+Handling parameters
+Declarative Pipeline supports parameters out-of-the-box, allowing the Pipeline to accept user-specified parameters at runtime via the parameters directive. Configuring parameters with Scripted Pipeline is done with the properties step, which can be found in the Snippet Generator.
+
+If you configured your pipeline to accept parameters using the Build with Parameters option, those parameters are accessible as members of the params variable.
+
+Assuming that a String parameter named "Greeting" has been configured in the Jenkinsfile, it can access that parameter via ${params.Greeting}:
+
+Jenkinsfile (Declarative Pipeline)
+pipeline {
+    agent any
+    parameters {
+        string(name: 'Greeting', defaultValue: 'Hello', description: 'How should I greet the world?')
+    }
+    stages {
+        stage('Example') {
+            steps {
+                echo "${params.Greeting} World!"
+            }
+        }
+    }
+}
+Toggle Scripted Pipeline (Advanced)
+Handling failure
+Declarative Pipeline supports robust failure handling by default via its post section which allows declaring a number of different "post conditions" such as: always, unstable, success, failure, and changed. The Pipeline Syntax section provides more detail on how to use the various post conditions.
+
+Jenkinsfile (Declarative Pipeline)
+pipeline {
+    agent any
+    stages {
+        stage('Test') {
+            steps {
+                sh 'make check'
+            }
+        }
+    }
+    post {
+        always {
+            junit '**/target/*.xml'
+        }
+        failure {
+            mail to: team@example.com, subject: 'The Pipeline failed :('
+        }
+    }
+}
+Toggle Scripted Pipeline (Advanced)
+Scripted Pipeline however relies on Groovy’s built-in try/catch/finally semantics for handling failures during execution of the Pipeline.
+
+In the Test example above, the sh step was modified to never return a non-zero exit code (sh 'make check || true'). This approach, while valid, means the following stages need to check currentBuild.result to know if there has been a test failure or not.
+
+An alternative way of handling this, which preserves the early-exit behavior of failures in Pipeline, while still giving junit the chance to capture test reports, is to use a series of try/finally blocks:
+
+Error-handling steps
+Jenkins Pipelines provide dedicated steps for flexible error handling, allowing you to control how your Pipeline responds to errors and warnings. These steps help you surface errors and warnings clearly in Jenkins, giving you control over whether the Pipeline fails, continues, or simply reports a warning. For more information, refer to:
+
+catchError
+
+error
+
+unstable
+
+warnError
+
+Using multiple agents
+In all the previous examples, only a single agent has been used. This means Jenkins will allocate an executor wherever one is available, regardless of how it is labeled or configured. Not only can this behavior be overridden, but Pipeline allows utilizing multiple agents in the Jenkins environment from within the same Jenkinsfile, which can be helpful for more advanced use-cases such as executing builds/tests across multiple platforms.
+
+In the example below, the "Build" stage will be performed on one agent and the built results will be reused on two subsequent agents, labelled "linux" and "windows" respectively, during the "Test" stage.
+
+Jenkinsfile (Declarative Pipeline)
+pipeline {
+    agent none
+    stages {
+        stage('Build') {
+            agent any
+            steps {
+                checkout scm
+                sh 'make'
+                stash includes: '**/target/*.jar', name: 'app' 
+            }
+        }
+        stage('Test on Linux') {
+            agent { 
+                label 'linux'
+            }
+            steps {
+                unstash 'app' 
+                sh 'make check'
+            }
+            post {
+                always {
+                    junit '**/target/*.xml'
+                }
+            }
+        }
+        stage('Test on Windows') {
+            agent {
+                label 'windows'
+            }
+            steps {
+                unstash 'app'
+                bat 'make check' 
+            }
+            post {
+                always {
+                    junit '**/target/*.xml'
+                }
+            }
+        }
+    }
+}
+Toggle Scripted Pipeline (Advanced)
+The stash step allows capturing files matching an inclusion pattern (**/target/*.jar) for reuse within the same Pipeline. Once the Pipeline has completed its execution, stashed files are deleted from the Jenkins controller.
+The parameter in agent/node allows for any valid Jenkins label expression. Consult the Pipeline Syntax section for more details.
+unstash will retrieve the named "stash" from the Jenkins controller into the Pipeline’s current workspace.
+The bat script allows for executing batch scripts on Windows-based platforms.
+Optional step arguments
+Pipeline follows the Groovy language convention of allowing parentheses to be omitted around method arguments.
+
+Many Pipeline steps also use the named-parameter syntax as a shorthand for creating a Map in Groovy, which uses the syntax [key1: value1, key2: value2]. Making statements like the following functionally equivalent:
+
+git url: 'git://example.com/amazing-project.git', branch: 'master'
+git([url: 'git://example.com/amazing-project.git', branch: 'master'])
+For convenience, when calling steps taking only one parameter (or only one mandatory parameter), the parameter name may be omitted, for example:
+
+sh 'echo hello' /* short form  */
+sh([script: 'echo hello'])  /* long form */
+Advanced Scripted Pipeline
+Scripted Pipeline is a domain-specific language [3] based on Groovy, most Groovy syntax can be used in Scripted Pipeline without modification.
+
+Parallel execution
+The example in the section above runs tests across two different platforms in a linear series. In practice, if the make check execution takes 30 minutes to complete, the "Test" stage would now take 60 minutes to complete!
+
+Fortunately, Pipeline has built-in functionality for executing portions of Scripted Pipeline in parallel, implemented in the aptly named parallel step.
+
+Refactoring the example above to use the parallel step:
+
+Jenkinsfile (Scripted Pipeline)
+stage('Build') {
+    /* .. snip .. */
+}
+
+stage('Test') {
+    parallel linux: {
+        node('linux') {
+            checkout scm
+            try {
+                unstash 'app'
+                sh 'make check'
+            }
+            finally {
+                junit '**/target/*.xml'
+            }
+        }
+    },
+    windows: {
+        node('windows') {
+            /* .. snip .. */
+        }
+    }
+}
+Instead of executing the tests on the "linux" and "windows" labelled nodes in series, they will now execute in parallel assuming the requisite capacity exists in the Jenkins environment.
+
+1. en.wikipedia.org/wiki/Source_control_management
+2. en.wikipedia.org/wiki/Single_Source_of_Truth
+3. en.wikipedia.org/wiki/Domain-specific_language

data/errors/error_01.txt

@@ -0,0 +1,29 @@
+Started by user Arvind Nandigam
+org.codehaus.groovy.control.MultipleCompilationErrorsException: startup failed:
+WorkflowScript: 10: expecting '}', found '' @ line 10, column 1.
+1 error
+
+	at org.codehaus.groovy.control.ErrorCollector.failIfErrors(ErrorCollector.java:309)
+	at org.codehaus.groovy.control.ErrorCollector.addFatalError(ErrorCollector.java:149)
+	at org.codehaus.groovy.control.ErrorCollector.addError(ErrorCollector.java:119)
+	at org.codehaus.groovy.control.ErrorCollector.addError(ErrorCollector.java:131)
+	at org.codehaus.groovy.control.SourceUnit.addError(SourceUnit.java:349)
+	at org.codehaus.groovy.antlr.AntlrParserPlugin.transformCSTIntoAST(AntlrParserPlugin.java:225)
+	at org.codehaus.groovy.antlr.AntlrParserPlugin.parseCST(AntlrParserPlugin.java:191)
+	at org.codehaus.groovy.control.SourceUnit.parse(SourceUnit.java:233)
+	at org.codehaus.groovy.control.CompilationUnit$1.call(CompilationUnit.java:189)
+	at org.codehaus.groovy.control.CompilationUnit.applyToSourceUnits(CompilationUnit.java:966)
+	at org.codehaus.groovy.control.CompilationUnit.doPhaseOperation(CompilationUnit.java:626)
+	at org.codehaus.groovy.control.CompilationUnit.processPhaseOperations(CompilationUnit.java:602)
+	at org.codehaus.groovy.control.CompilationUnit.compile(CompilationUnit.java:579)
+	at groovy.lang.GroovyClassLoader.doParseClass(GroovyClassLoader.java:323)
+	at groovy.lang.GroovyClassLoader.parseClass(GroovyClassLoader.java:293)
+	at PluginClassLoader for script-security//org.jenkinsci.plugins.scriptsecurity.sandbox.groovy.GroovySandbox$Scope.parse(GroovySandbox.java:162)
+	at PluginClassLoader for workflow-cps//org.jenkinsci.plugins.workflow.cps.CpsGroovyShell.doParse(CpsGroovyShell.java:202)
+	at PluginClassLoader for workflow-cps//org.jenkinsci.plugins.workflow.cps.CpsGroovyShell.reparse(CpsGroovyShell.java:186)
+	at PluginClassLoader for workflow-cps//org.jenkinsci.plugins.workflow.cps.CpsFlowExecution.parseScript(CpsFlowExecution.java:669)
+	at PluginClassLoader for workflow-cps//org.jenkinsci.plugins.workflow.cps.CpsFlowExecution.start(CpsFlowExecution.java:615)
+	at PluginClassLoader for workflow-job//org.jenkinsci.plugins.workflow.job.WorkflowRun.run(WorkflowRun.java:341)
+	at hudson.model.ResourceController.execute(ResourceController.java:101)
+	at hudson.model.Executor.run(Executor.java:460)
+Finished: FAILURE

data/errors/error_02.txt

@@ -0,0 +1,29 @@
+Started by user Arvind Nandigam
+org.codehaus.groovy.control.MultipleCompilationErrorsException: startup failed:
+WorkflowScript: 9: expecting '}', found '' @ line 9, column 1.
+1 error
+
+	at org.codehaus.groovy.control.ErrorCollector.failIfErrors(ErrorCollector.java:309)
+	at org.codehaus.groovy.control.ErrorCollector.addFatalError(ErrorCollector.java:149)
+	at org.codehaus.groovy.control.ErrorCollector.addError(ErrorCollector.java:119)
+	at org.codehaus.groovy.control.ErrorCollector.addError(ErrorCollector.java:131)
+	at org.codehaus.groovy.control.SourceUnit.addError(SourceUnit.java:349)
+	at org.codehaus.groovy.antlr.AntlrParserPlugin.transformCSTIntoAST(AntlrParserPlugin.java:225)
+	at org.codehaus.groovy.antlr.AntlrParserPlugin.parseCST(AntlrParserPlugin.java:191)
+	at org.codehaus.groovy.control.SourceUnit.parse(SourceUnit.java:233)
+	at org.codehaus.groovy.control.CompilationUnit$1.call(CompilationUnit.java:189)
+	at org.codehaus.groovy.control.CompilationUnit.applyToSourceUnits(CompilationUnit.java:966)
+	at org.codehaus.groovy.control.CompilationUnit.doPhaseOperation(CompilationUnit.java:626)
+	at org.codehaus.groovy.control.CompilationUnit.processPhaseOperations(CompilationUnit.java:602)
+	at org.codehaus.groovy.control.CompilationUnit.compile(CompilationUnit.java:579)
+	at groovy.lang.GroovyClassLoader.doParseClass(GroovyClassLoader.java:323)
+	at groovy.lang.GroovyClassLoader.parseClass(GroovyClassLoader.java:293)
+	at PluginClassLoader for script-security//org.jenkinsci.plugins.scriptsecurity.sandbox.groovy.GroovySandbox$Scope.parse(GroovySandbox.java:162)
+	at PluginClassLoader for workflow-cps//org.jenkinsci.plugins.workflow.cps.CpsGroovyShell.doParse(CpsGroovyShell.java:202)
+	at PluginClassLoader for workflow-cps//org.jenkinsci.plugins.workflow.cps.CpsGroovyShell.reparse(CpsGroovyShell.java:186)
+	at PluginClassLoader for workflow-cps//org.jenkinsci.plugins.workflow.cps.CpsFlowExecution.parseScript(CpsFlowExecution.java:669)
+	at PluginClassLoader for workflow-cps//org.jenkinsci.plugins.workflow.cps.CpsFlowExecution.start(CpsFlowExecution.java:615)
+	at PluginClassLoader for workflow-job//org.jenkinsci.plugins.workflow.job.WorkflowRun.run(WorkflowRun.java:341)
+	at hudson.model.ResourceController.execute(ResourceController.java:101)
+	at hudson.model.Executor.run(Executor.java:460)
+Finished: FAILURE

data/errors/error_03.txt

@@ -0,0 +1,11 @@
+Started by user Arvind Nandigam
+[Pipeline] Start of Pipeline
+[Pipeline] stage
+[Pipeline] { (Build)
+[Pipeline] sh
+[Pipeline] error
+[Pipeline] }
+[Pipeline] // stage
+[Pipeline] End of Pipeline
+ERROR: Attempted to execute a step that requires a node context while ‘agent none’ was specified. Be sure to specify your own ‘node { ... }’ blocks when using ‘agent none’.
+Finished: FAILURE

data/errors/error_04.txt

@@ -0,0 +1,48 @@
+Started by user Arvind Nandigam
+[Pipeline] Start of Pipeline
+[Pipeline] node
+Running on Jenkins in /var/jenkins_home/workspace/error_04
+[Pipeline] {
+[Pipeline] stage
+[Pipeline] { (Checkout)
+[Pipeline] git
+The recommended git tool is: NONE
+No credentials specified
+Cloning the remote Git repository
+Cloning repository https://github.com/example/repo.git
+ > git init /var/jenkins_home/workspace/error_04 # timeout=10
+Fetching upstream changes from https://github.com/example/repo.git
+ > git --version # timeout=10
+ > git --version # 'git version 2.47.3'
+ > git fetch --tags --force --progress -- https://github.com/example/repo.git +refs/heads/*:refs/remotes/origin/* # timeout=10
+ERROR: Error cloning remote repo 'origin'
+hudson.plugins.git.GitException: Command "git fetch --tags --force --progress -- https://github.com/example/repo.git +refs/heads/*:refs/remotes/origin/*" returned status code 128:
+stdout: 
+stderr: remote: Invalid username or token. Password authentication is not supported for Git operations.
+fatal: Authentication failed for 'https://github.com/example/repo.git/'
+
+	at PluginClassLoader for git-client//org.jenkinsci.plugins.gitclient.CliGitAPIImpl.launchCommandIn(CliGitAPIImpl.java:2848)
+	at PluginClassLoader for git-client//org.jenkinsci.plugins.gitclient.CliGitAPIImpl.launchCommandWithCredentials(CliGitAPIImpl.java:2189)
+	at PluginClassLoader for git-client//org.jenkinsci.plugins.gitclient.CliGitAPIImpl$1.execute(CliGitAPIImpl.java:638)
+	at PluginClassLoader for git-client//org.jenkinsci.plugins.gitclient.CliGitAPIImpl$2.execute(CliGitAPIImpl.java:880)
+	at PluginClassLoader for git//hudson.plugins.git.GitSCM.retrieveChanges(GitSCM.java:1220)
+	at PluginClassLoader for git//hudson.plugins.git.GitSCM._checkout(GitSCM.java:1310)
+	at PluginClassLoader for git//hudson.plugins.git.GitSCM.checkout(GitSCM.java:1277)
+	at PluginClassLoader for workflow-scm-step//org.jenkinsci.plugins.workflow.steps.scm.SCMStep.checkout(SCMStep.java:136)
+	at PluginClassLoader for workflow-scm-step//org.jenkinsci.plugins.workflow.steps.scm.SCMStep$StepExecutionImpl.run(SCMStep.java:101)
+	at PluginClassLoader for workflow-scm-step//org.jenkinsci.plugins.workflow.steps.scm.SCMStep$StepExecutionImpl.run(SCMStep.java:88)
+	at PluginClassLoader for workflow-step-api//org.jenkinsci.plugins.workflow.steps.SynchronousNonBlockingStepExecution.lambda$start$0(SynchronousNonBlockingStepExecution.java:49)
+	at java.base/java.util.concurrent.Executors$RunnableAdapter.call(Unknown Source)
+	at java.base/java.util.concurrent.FutureTask.run(Unknown Source)
+	at java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(Unknown Source)
+	at java.base/java.util.concurrent.ThreadPoolExecutor$Worker.run(Unknown Source)
+	at java.base/java.lang.Thread.run(Unknown Source)
+ERROR: Error cloning remote repo 'origin'
+ERROR: Maximum checkout retry attempts reached, aborting
+[Pipeline] }
+[Pipeline] // stage
+[Pipeline] }
+[Pipeline] // node
+[Pipeline] End of Pipeline
+ERROR: Error cloning remote repo 'origin'
+Finished: FAILURE

data/errors/error_05.txt

@@ -0,0 +1,16 @@
+Started by user Arvind Nandigam
+[Pipeline] Start of Pipeline
+[Pipeline] node
+Running on Jenkins in /var/jenkins_home/workspace/error_05
+[Pipeline] {
+[Pipeline] stage
+[Pipeline] { (Auth)
+[Pipeline] withCredentials
+[Pipeline] // withCredentials
+[Pipeline] }
+[Pipeline] // stage
+[Pipeline] }
+[Pipeline] // node
+[Pipeline] End of Pipeline
+ERROR: Could not find credentials entry with ID 'does-not-exist'
+Finished: FAILURE

data/errors/error_06.txt

@@ -0,0 +1,10 @@
+Started by user Arvind Nandigam
+[Pipeline] Start of Pipeline
+[Pipeline] node
+Still waiting to schedule task
+‘Jenkins’ doesn’t have label ‘no-such-node’
+Aborted by Arvind Nandigam
+[Pipeline] // node
+[Pipeline] End of Pipeline
+org.jenkinsci.plugins.workflow.actions.ErrorAction$ErrorId: db6e2408-0d72-4f17-a842-4d2ecce38130
+Finished: ABORTED

data/errors/error_07.txt

@@ -0,0 +1,25 @@
+Started by user Arvind Nandigam
+
+org.codehaus.groovy.control.MultipleCompilationErrorsException: startup failed:
+WorkflowScript: 6: Expected a step @ line 6, column 17.
+                   def x = 1
+                   ^
+
+1 error
+
+	at org.codehaus.groovy.control.ErrorCollector.failIfErrors(ErrorCollector.java:309)
+	at org.codehaus.groovy.control.CompilationUnit.applyToPrimaryClassNodes(CompilationUnit.java:1107)
+	at org.codehaus.groovy.control.CompilationUnit.doPhaseOperation(CompilationUnit.java:624)
+	at org.codehaus.groovy.control.CompilationUnit.processPhaseOperations(CompilationUnit.java:602)
+	at org.codehaus.groovy.control.CompilationUnit.compile(CompilationUnit.java:579)
+	at groovy.lang.GroovyClassLoader.doParseClass(GroovyClassLoader.java:323)
+	at groovy.lang.GroovyClassLoader.parseClass(GroovyClassLoader.java:293)
+	at PluginClassLoader for script-security//org.jenkinsci.plugins.scriptsecurity.sandbox.groovy.GroovySandbox$Scope.parse(GroovySandbox.java:162)
+	at PluginClassLoader for workflow-cps//org.jenkinsci.plugins.workflow.cps.CpsGroovyShell.doParse(CpsGroovyShell.java:202)
+	at PluginClassLoader for workflow-cps//org.jenkinsci.plugins.workflow.cps.CpsGroovyShell.reparse(CpsGroovyShell.java:186)
+	at PluginClassLoader for workflow-cps//org.jenkinsci.plugins.workflow.cps.CpsFlowExecution.parseScript(CpsFlowExecution.java:669)
+	at PluginClassLoader for workflow-cps//org.jenkinsci.plugins.workflow.cps.CpsFlowExecution.start(CpsFlowExecution.java:615)
+	at PluginClassLoader for workflow-job//org.jenkinsci.plugins.workflow.job.WorkflowRun.run(WorkflowRun.java:341)
+	at hudson.model.ResourceController.execute(ResourceController.java:101)
+	at hudson.model.Executor.run(Executor.java:460)
+Finished: FAILURE

data/errors/error_08.txt

@@ -0,0 +1,24 @@
+Started by user Arvind Nandigam
+org.codehaus.groovy.control.MultipleCompilationErrorsException: startup failed:
+WorkflowScript: 3: Invalid agent type "docker" specified. Must be one of [any, label, none] @ line 3, column 9.
+           docker {
+           ^
+
+1 error
+
+	at org.codehaus.groovy.control.ErrorCollector.failIfErrors(ErrorCollector.java:309)
+	at org.codehaus.groovy.control.CompilationUnit.applyToPrimaryClassNodes(CompilationUnit.java:1107)
+	at org.codehaus.groovy.control.CompilationUnit.doPhaseOperation(CompilationUnit.java:624)
+	at org.codehaus.groovy.control.CompilationUnit.processPhaseOperations(CompilationUnit.java:602)
+	at org.codehaus.groovy.control.CompilationUnit.compile(CompilationUnit.java:579)
+	at groovy.lang.GroovyClassLoader.doParseClass(GroovyClassLoader.java:323)
+	at groovy.lang.GroovyClassLoader.parseClass(GroovyClassLoader.java:293)
+	at PluginClassLoader for script-security//org.jenkinsci.plugins.scriptsecurity.sandbox.groovy.GroovySandbox$Scope.parse(GroovySandbox.java:162)
+	at PluginClassLoader for workflow-cps//org.jenkinsci.plugins.workflow.cps.CpsGroovyShell.doParse(CpsGroovyShell.java:202)
+	at PluginClassLoader for workflow-cps//org.jenkinsci.plugins.workflow.cps.CpsGroovyShell.reparse(CpsGroovyShell.java:186)
+	at PluginClassLoader for workflow-cps//org.jenkinsci.plugins.workflow.cps.CpsFlowExecution.parseScript(CpsFlowExecution.java:669)
+	at PluginClassLoader for workflow-cps//org.jenkinsci.plugins.workflow.cps.CpsFlowExecution.start(CpsFlowExecution.java:615)
+	at PluginClassLoader for workflow-job//org.jenkinsci.plugins.workflow.job.WorkflowRun.run(WorkflowRun.java:341)
+	at hudson.model.ResourceController.execute(ResourceController.java:101)
+	at hudson.model.Executor.run(Executor.java:460)
+Finished: FAILURE

model_cache/models--sentence-transformers--all-MiniLM-L6-v2/blobs/53aa51172d142c89d9012cce15ae4d6cc0ca6895895114379cacb4fab128d9db

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:53aa51172d142c89d9012cce15ae4d6cc0ca6895895114379cacb4fab128d9db
+size 90868376

model_cache/models--sentence-transformers--all-MiniLM-L6-v2/blobs/58d4a9a45664eb9e12de9549c548c09b6134c17f

@@ -0,0 +1,173 @@
+---
+language: en
+license: apache-2.0
+library_name: sentence-transformers
+tags:
+- sentence-transformers
+- feature-extraction
+- sentence-similarity
+- transformers
+datasets:
+- s2orc
+- flax-sentence-embeddings/stackexchange_xml
+- ms_marco
+- gooaq
+- yahoo_answers_topics
+- code_search_net
+- search_qa
+- eli5
+- snli
+- multi_nli
+- wikihow
+- natural_questions
+- trivia_qa
+- embedding-data/sentence-compression
+- embedding-data/flickr30k-captions
+- embedding-data/altlex
+- embedding-data/simple-wiki
+- embedding-data/QQP
+- embedding-data/SPECTER
+- embedding-data/PAQ_pairs
+- embedding-data/WikiAnswers
+pipeline_tag: sentence-similarity
+---
+
+
+# all-MiniLM-L6-v2
+This is a [sentence-transformers](https://www.SBERT.net) model: It maps sentences & paragraphs to a 384 dimensional dense vector space and can be used for tasks like clustering or semantic search.
+
+## Usage (Sentence-Transformers)
+Using this model becomes easy when you have [sentence-transformers](https://www.SBERT.net) installed:
+
+```
+pip install -U sentence-transformers
+```
+
+Then you can use the model like this:
+```python
+from sentence_transformers import SentenceTransformer
+sentences = ["This is an example sentence", "Each sentence is converted"]
+
+model = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2')
+embeddings = model.encode(sentences)
+print(embeddings)
+```
+
+## Usage (HuggingFace Transformers)
+Without [sentence-transformers](https://www.SBERT.net), you can use the model like this: First, you pass your input through the transformer model, then you have to apply the right pooling-operation on-top of the contextualized word embeddings.
+
+```python
+from transformers import AutoTokenizer, AutoModel
+import torch
+import torch.nn.functional as F
+
+#Mean Pooling - Take attention mask into account for correct averaging
+def mean_pooling(model_output, attention_mask):
+    token_embeddings = model_output[0] #First element of model_output contains all token embeddings
+    input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
+    return torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(input_mask_expanded.sum(1), min=1e-9)
+
+
+# Sentences we want sentence embeddings for
+sentences = ['This is an example sentence', 'Each sentence is converted']
+
+# Load model from HuggingFace Hub
+tokenizer = AutoTokenizer.from_pretrained('sentence-transformers/all-MiniLM-L6-v2')
+model = AutoModel.from_pretrained('sentence-transformers/all-MiniLM-L6-v2')
+
+# Tokenize sentences
+encoded_input = tokenizer(sentences, padding=True, truncation=True, return_tensors='pt')
+
+# Compute token embeddings
+with torch.no_grad():
+    model_output = model(**encoded_input)
+
+# Perform pooling
+sentence_embeddings = mean_pooling(model_output, encoded_input['attention_mask'])
+
+# Normalize embeddings
+sentence_embeddings = F.normalize(sentence_embeddings, p=2, dim=1)
+
+print("Sentence embeddings:")
+print(sentence_embeddings)
+```
+
+------
+
+## Background
+
+The project aims to train sentence embedding models on very large sentence level datasets using a self-supervised 
+contrastive learning objective. We used the pretrained [`nreimers/MiniLM-L6-H384-uncased`](https://huggingface.co/nreimers/MiniLM-L6-H384-uncased) model and fine-tuned in on a 
+1B sentence pairs dataset. We use a contrastive learning objective: given a sentence from the pair, the model should predict which out of a set of randomly sampled other sentences, was actually paired with it in our dataset.
+
+We developed this model during the 
+[Community week using JAX/Flax for NLP & CV](https://discuss.huggingface.co/t/open-to-the-community-community-week-using-jax-flax-for-nlp-cv/7104), 
+organized by Hugging Face. We developed this model as part of the project:
+[Train the Best Sentence Embedding Model Ever with 1B Training Pairs](https://discuss.huggingface.co/t/train-the-best-sentence-embedding-model-ever-with-1b-training-pairs/7354). We benefited from efficient hardware infrastructure to run the project: 7 TPUs v3-8, as well as intervention from Googles Flax, JAX, and Cloud team member about efficient deep learning frameworks.
+
+## Intended uses
+
+Our model is intended to be used as a sentence and short paragraph encoder. Given an input text, it outputs a vector which captures 
+the semantic information. The sentence vector may be used for information retrieval, clustering or sentence similarity tasks.
+
+By default, input text longer than 256 word pieces is truncated.
+
+
+## Training procedure
+
+### Pre-training 
+
+We use the pretrained [`nreimers/MiniLM-L6-H384-uncased`](https://huggingface.co/nreimers/MiniLM-L6-H384-uncased) model. Please refer to the model card for more detailed information about the pre-training procedure.
+
+### Fine-tuning 
+
+We fine-tune the model using a contrastive objective. Formally, we compute the cosine similarity from each possible sentence pairs from the batch.
+We then apply the cross entropy loss by comparing with true pairs.
+
+#### Hyper parameters
+
+We trained our model on a TPU v3-8. We train the model during 100k steps using a batch size of 1024 (128 per TPU core).
+We use a learning rate warm up of 500. The sequence length was limited to 128 tokens. We used the AdamW optimizer with
+a 2e-5 learning rate. The full training script is accessible in this current repository: `train_script.py`.
+
+#### Training data
+
+We use the concatenation from multiple datasets to fine-tune our model. The total number of sentence pairs is above 1 billion sentences.
+We sampled each dataset given a weighted probability which configuration is detailed in the `data_config.json` file.
+
+
+| Dataset                                                  | Paper                                    | Number of training tuples  |
+|--------------------------------------------------------|:----------------------------------------:|:--------------------------:|
+| [Reddit comments (2015-2018)](https://github.com/PolyAI-LDN/conversational-datasets/tree/master/reddit) | [paper](https://arxiv.org/abs/1904.06472) | 726,484,430 |
+| [S2ORC](https://github.com/allenai/s2orc) Citation pairs (Abstracts) | [paper](https://aclanthology.org/2020.acl-main.447/) | 116,288,806 |
+| [WikiAnswers](https://github.com/afader/oqa#wikianswers-corpus) Duplicate question pairs | [paper](https://doi.org/10.1145/2623330.2623677) | 77,427,422 |
+| [PAQ](https://github.com/facebookresearch/PAQ) (Question, Answer) pairs | [paper](https://arxiv.org/abs/2102.07033) | 64,371,441 |
+| [S2ORC](https://github.com/allenai/s2orc) Citation pairs (Titles) | [paper](https://aclanthology.org/2020.acl-main.447/) | 52,603,982 |
+| [S2ORC](https://github.com/allenai/s2orc) (Title, Abstract) | [paper](https://aclanthology.org/2020.acl-main.447/) | 41,769,185 |
+| [Stack Exchange](https://huggingface.co/datasets/flax-sentence-embeddings/stackexchange_xml) (Title, Body) pairs  | - | 25,316,456 |
+| [Stack Exchange](https://huggingface.co/datasets/flax-sentence-embeddings/stackexchange_xml) (Title+Body, Answer) pairs  | - | 21,396,559 |
+| [Stack Exchange](https://huggingface.co/datasets/flax-sentence-embeddings/stackexchange_xml) (Title, Answer) pairs  | - | 21,396,559 |
+| [MS MARCO](https://microsoft.github.io/msmarco/) triplets | [paper](https://doi.org/10.1145/3404835.3462804) | 9,144,553 |
+| [GOOAQ: Open Question Answering with Diverse Answer Types](https://github.com/allenai/gooaq) | [paper](https://arxiv.org/pdf/2104.08727.pdf) | 3,012,496 |
+| [Yahoo Answers](https://www.kaggle.com/soumikrakshit/yahoo-answers-dataset) (Title, Answer) | [paper](https://proceedings.neurips.cc/paper/2015/hash/250cf8b51c773f3f8dc8b4be867a9a02-Abstract.html) | 1,198,260 |
+| [Code Search](https://huggingface.co/datasets/code_search_net) | - | 1,151,414 |
+| [COCO](https://cocodataset.org/#home) Image captions | [paper](https://link.springer.com/chapter/10.1007%2F978-3-319-10602-1_48) | 828,395|
+| [SPECTER](https://github.com/allenai/specter) citation triplets | [paper](https://doi.org/10.18653/v1/2020.acl-main.207) | 684,100 |
+| [Yahoo Answers](https://www.kaggle.com/soumikrakshit/yahoo-answers-dataset) (Question, Answer) | [paper](https://proceedings.neurips.cc/paper/2015/hash/250cf8b51c773f3f8dc8b4be867a9a02-Abstract.html) | 681,164 |
+| [Yahoo Answers](https://www.kaggle.com/soumikrakshit/yahoo-answers-dataset) (Title, Question) | [paper](https://proceedings.neurips.cc/paper/2015/hash/250cf8b51c773f3f8dc8b4be867a9a02-Abstract.html) | 659,896 |
+| [SearchQA](https://huggingface.co/datasets/search_qa) | [paper](https://arxiv.org/abs/1704.05179) | 582,261 |
+| [Eli5](https://huggingface.co/datasets/eli5) | [paper](https://doi.org/10.18653/v1/p19-1346) | 325,475 |
+| [Flickr 30k](https://shannon.cs.illinois.edu/DenotationGraph/) | [paper](https://transacl.org/ojs/index.php/tacl/article/view/229/33) | 317,695 |
+| [Stack Exchange](https://huggingface.co/datasets/flax-sentence-embeddings/stackexchange_xml) Duplicate questions (titles) | | 304,525 |
+| AllNLI ([SNLI](https://nlp.stanford.edu/projects/snli/) and [MultiNLI](https://cims.nyu.edu/~sbowman/multinli/) | [paper SNLI](https://doi.org/10.18653/v1/d15-1075), [paper MultiNLI](https://doi.org/10.18653/v1/n18-1101) | 277,230 | 
+| [Stack Exchange](https://huggingface.co/datasets/flax-sentence-embeddings/stackexchange_xml) Duplicate questions (bodies) | | 250,519 |
+| [Stack Exchange](https://huggingface.co/datasets/flax-sentence-embeddings/stackexchange_xml) Duplicate questions (titles+bodies) | | 250,460 |
+| [Sentence Compression](https://github.com/google-research-datasets/sentence-compression) | [paper](https://www.aclweb.org/anthology/D13-1155/) | 180,000 |
+| [Wikihow](https://github.com/pvl/wikihow_pairs_dataset) | [paper](https://arxiv.org/abs/1810.09305) | 128,542 |
+| [Altlex](https://github.com/chridey/altlex/) | [paper](https://aclanthology.org/P16-1135.pdf) | 112,696 |
+| [Quora Question Triplets](https://quoradata.quora.com/First-Quora-Dataset-Release-Question-Pairs) | - | 103,663 |
+| [Simple Wikipedia](https://cs.pomona.edu/~dkauchak/simplification/) | [paper](https://www.aclweb.org/anthology/P11-2117/) | 102,225 |
+| [Natural Questions (NQ)](https://ai.google.com/research/NaturalQuestions) | [paper](https://transacl.org/ojs/index.php/tacl/article/view/1455) | 100,231 |
+| [SQuAD2.0](https://rajpurkar.github.io/SQuAD-explorer/) | [paper](https://aclanthology.org/P18-2124.pdf) | 87,599 |
+| [TriviaQA](https://huggingface.co/datasets/trivia_qa) | - | 73,346 |
+| **Total** | | **1,170,060,424** |

model_cache/models--sentence-transformers--all-MiniLM-L6-v2/blobs/59d594003bf59880a884c574bf88ef7555bb0202

@@ -0,0 +1,4 @@
+{
+  "max_seq_length": 256,
+  "do_lower_case": false
+}

model_cache/models--sentence-transformers--all-MiniLM-L6-v2/blobs/72b987fd805cfa2b58c4c8c952b274a11bfd5a00

@@ -0,0 +1,24 @@
+{
+  "_name_or_path": "nreimers/MiniLM-L6-H384-uncased",
+  "architectures": [
+    "BertModel"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "gradient_checkpointing": false,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 384,
+  "initializer_range": 0.02,
+  "intermediate_size": 1536,
+  "layer_norm_eps": 1e-12,
+  "max_position_embeddings": 512,
+  "model_type": "bert",
+  "num_attention_heads": 12,
+  "num_hidden_layers": 6,
+  "pad_token_id": 0,
+  "position_embedding_type": "absolute",
+  "transformers_version": "4.8.2",
+  "type_vocab_size": 2,
+  "use_cache": true,
+  "vocab_size": 30522
+}

model_cache/models--sentence-transformers--all-MiniLM-L6-v2/blobs/952a9b81c0bfd99800fabf352f69c7ccd46c5e43

@@ -0,0 +1,20 @@
+[
+  {
+    "idx": 0,
+    "name": "0",
+    "path": "",
+    "type": "sentence_transformers.models.Transformer"
+  },
+  {
+    "idx": 1,
+    "name": "1",
+    "path": "1_Pooling",
+    "type": "sentence_transformers.models.Pooling"
+  },
+  {
+    "idx": 2,
+    "name": "2",
+    "path": "2_Normalize",
+    "type": "sentence_transformers.models.Normalize"
+  }
+]

model_cache/models--sentence-transformers--all-MiniLM-L6-v2/blobs/c79f2b6a0cea6f4b564fed1938984bace9d30ff0

@@ -0,0 +1 @@
+{"do_lower_case": true, "unk_token": "[UNK]", "sep_token": "[SEP]", "pad_token": "[PAD]", "cls_token": "[CLS]", "mask_token": "[MASK]", "tokenize_chinese_chars": true, "strip_accents": null, "name_or_path": "nreimers/MiniLM-L6-H384-uncased", "do_basic_tokenize": true, "never_split": null, "tokenizer_class": "BertTokenizer", "model_max_length": 512}

model_cache/models--sentence-transformers--all-MiniLM-L6-v2/blobs/d1514c3162bbe87b343f565fadc62e6c06f04f03

@@ -0,0 +1,7 @@
+{
+  "word_embedding_dimension": 384,
+  "pooling_mode_cls_token": false,
+  "pooling_mode_mean_tokens": true,
+  "pooling_mode_max_tokens": false,
+  "pooling_mode_mean_sqrt_len_tokens": false
+}

model_cache/models--sentence-transformers--all-MiniLM-L6-v2/blobs/e7b0375001f109a6b8873d756ad4f7bbb15fbaa5

@@ -0,0 +1 @@
+{"unk_token": "[UNK]", "sep_token": "[SEP]", "pad_token": "[PAD]", "cls_token": "[CLS]", "mask_token": "[MASK]"}

model_cache/models--sentence-transformers--all-MiniLM-L6-v2/blobs/fd1b291129c607e5d49799f87cb219b27f98acdf

@@ -0,0 +1,7 @@
+{
+  "__version__": {
+    "sentence_transformers": "2.0.0",
+    "transformers": "4.6.1",
+    "pytorch": "1.8.1"
+  }
+}

model_cache/models--sentence-transformers--all-MiniLM-L6-v2/refs/main

@@ -0,0 +1 @@
+c9745ed1d9f207416be6d2e6f8de32d1f16199bf

model_cache/models--sentence-transformers--all-MiniLM-L6-v2/snapshots/c9745ed1d9f207416be6d2e6f8de32d1f16199bf/model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
+size 0