DSL
- How do I access Pipeline DSLs from inside a Groovy class?
jobs
- Create a Permanent Agent from Groovy Console
agents
- Monitor and Restart Offline Agents
others

references:

Jenkins Features Controlled with System Properties

DSL

How do I access Pipeline DSLs from inside a Groovy class?

class C implements Serializable {
 def stuff(steps) {
   steps.node {
     steps.sh 'echo hello'
   }
 }
}
def c = new C()
c.stuff(steps)

or

class C implements Serializable {
  def stuff(script) {
    script.node {
      script.echo "running in ${script.env.JENKINS_URL}"
    }
  }
}
def c = new C()
c.stuff(this)

jobs

Create a Permanent Agent from Groovy Console

import hudson.model.*
import jenkins.model.*
import hudson.slaves.*
import hudson.slaves.EnvironmentVariablesNodeProperty.Entry

/**
* INSERT "Launch Method" SNIPPET HERE
 */

// Define a "Permanent Agent"
Slave agent = new DumbSlave(
        "agent-node",
        "/home/jenkins",
        launcher)
agent.nodeDescription = "Agent node description"
agent.numExecutors = 1
agent.labelString = "agent-node-label"
agent.mode = Node.Mode.NORMAL
agent.retentionStrategy = new RetentionStrategy.Always()

List<Entry> env = new ArrayList<Entry>()
env.add(new Entry("key1","value1"))
env.add(new Entry("key2","value2"))
EnvironmentVariablesNodeProperty envPro = new EnvironmentVariablesNodeProperty(env)

agent.getNodeProperties().add(envPro)

// Create a "Permanent Agent"
Jenkins.instance.addNode(agent)

return "Node has been created successfully."

or:CloudBees SSH Build Agents plugin 2.0 and newer

import com.cloudbees.jenkins.plugins.sshslaves.verification.*
import com.cloudbees.jenkins.plugins.sshslaves.SSHConnectionDetails

// Pick one of the strategies from the comments below this line
ServerKeyVerificationStrategy serverKeyVerificationStrategy = new TrustInitialConnectionVerificationStrategy(false)
// = new TrustInitialConnectionVerificationStrategy(false /* "Require manual verification of initial connection" */) // "Manually trusted key verification Strategy"
// = new ManuallyConnectionVerificationStrategy("<your-key-here>") // "Manually provided key verification Strategy"
// = new KnownHostsConnectionVerificationStrategy() // "~/.ssh/known_hosts file Verification Strategy"
// = new BlindTrustConnectionVerificationStrategy() // "Non-verifying Verification Strategy"

// Define a "Launch method": "Launch agents via SSH"
ComputerLauncher launcher = new com.cloudbees.jenkins.plugins.sshslaves.SSHLauncher(
        "host", // Host
        new SSHConnectionDetails(
                "credentialsId", // Credentials ID
                22, // port
                (String)null, // JavaPath
                (String)null, // JVM Options
                (String)null, // Prefix Start Agent Command
                (String)null, // Suffix Start Agent Command
                (boolean)false, // Log environment on initial connect
                (ServerKeyVerificationStrategy) serverKeyVerificationStrategy // Host Key Verification Strategy
        )
)

agents

Monitor and Restart Offline Agents

import hudson.node_monitors.*
import hudson.slaves.*
import java.util.concurrent.*

jenkins = Jenkins.instance

import javax.mail.internet.*
import javax.mail.*
import javax.activation.*


def sendMail (agent, cause) {

 message = agent + " agent is down. Check http://JENKINS_HOSTNAME:JENKINS_PORT/computer/" + agent + "\nBecause " + cause
 subject = agent + " agent is offline"
 toAddress = "JENKINS_ADMIN@YOUR_DOMAIN"
 fromAddress = "JENKINS@YOUR_DOMAIN"
 host = "SMTP_SERVER"
 port = "SMTP_PORT"

 Properties mprops = new Properties()
 mprops.setProperty("mail.transport.protocol","smtp")
 mprops.setProperty("mail.host",host)
 mprops.setProperty("mail.smtp.port",port)

 Session lSession = Session.getDefaultInstance(mprops,null)
 MimeMessage msg = new MimeMessage(lSession)


 //tokenize out the recipients in case they came in as a list
 StringTokenizer tok = new StringTokenizer(toAddress,";")
 ArrayList emailTos = new ArrayList()
 while(tok.hasMoreElements()) {
   emailTos.add(new InternetAddress(tok.nextElement().toString()))
 }
 InternetAddress[] to = new InternetAddress[emailTos.size()]
 to = (InternetAddress[]) emailTos.toArray(to)
 msg.setRecipients(MimeMessage.RecipientType.TO,to)
 InternetAddress fromAddr = new InternetAddress(fromAddress)
 msg.setFrom(fromAddr)
 msg.setFrom(new InternetAddress(fromAddress))
 msg.setSubject(subject)
 msg.setText(message)

 Transport transporter = lSession.getTransport("smtp")
 transporter.connect()
 transporter.send(msg)
}

def getEnviron(computer) {
   def env
   def thread = Thread.start("Getting env from ${computer.name}", { env = computer.environment })
   thread.join(2000)
   if (thread.isAlive()) thread.interrupt()
   env
}

def agentAccessible(computer) {
    getEnviron(computer)?.get('PATH') != null
}

def numberOfflineNodes = 0
def numberNodes = 0
for (agent in jenkins.getNodes()) {
   def computer = agent.computer
   numberNodes ++
   println ""
   println "Checking computer ${computer.name}:"
   def isOK = (agentAccessible(computer) && !computer.offline)
   if (isOK) {
     println "\t\tOK, got PATH back from slave ${computer.name}."
     println('\tcomputer.isOffline: ' + slave.getComputer().isOffline())
     println('\tcomputer.isTemporarilyOffline: ' + slave.getComputer().isTemporarilyOffline())
     println('\tcomputer.getOfflineCause: ' + slave.getComputer().getOfflineCause())
     println('\tcomputer.offline: ' + computer.offline)
   } else {
     numberOfflineNodes ++
     println "  ERROR: can't get PATH from agent ${computer.name}."
     println('\tcomputer.isOffline: ' + agent.getComputer().isOffline())
     println('\tcomputer.isTemporarilyOffline: ' + agent.getComputer().isTemporarilyOffline())
     println('\tcomputer.getOfflineCause: ' + agent.getComputer().getOfflineCause())
     println('\tcomputer.offline: ' + computer.offline)
     sendMail(computer.name, agent.getComputer().getOfflineCause().toString())
     if (agent.getComputer().isTemporarilyOffline()) {
       if (!agent.getComputer().getOfflineCause().toString().contains("Disconnected by")) {
         computer.setTemporarilyOffline(false, agent.getComputer().getOfflineCause())
       }
     } else {
         computer.connect(true)
     }
   }
 }
println ("Number of Offline Nodes: " + numberOfflineNodes)
println ("Number of Nodes: " + numberNodes)

others

[!NOTE|label:references:]

scripts:

jira-publisher.groovy

run shell scripts in a cluster-operation

def exec(cmd) {
  println cmd
    def process = new ProcessBuilder([ "sh", "-c", cmd])
    .directory(new File("/tmp"))
    .redirectErrorStream(true)
    .start()
    process.outputStream.close()
    process.inputStream.eachLine {println it}
  process.waitFor()
  return process.exitValue()
}

[
  "echo hello world",
  "ls -al"
].each {
  exec(it)
}

get all running thread

  Thread.getAllStackTraces().keySet().each() {
    println it.getName()
  }

kill running thread

or using t.stop() instead of t.interrupt()

Thread.getAllStackTraces().keySet().each() { t ->
  if (t.getName()=="YOUR THREAD NAME" ) { t.interrupt(); }
}

Automate configuring via Jenkins Script Console

import net.sf.json.JSONArray
import net.sf.json.JSONObject
import org.thoughtslive.jenkins.plugins.jira.JiraStepsConfig
import org.thoughtslive.jenkins.plugins.jira.Site

//global user-defined configuration
JSONArray sitesConf = [
  [
    name: 'another',
    url: 'http://example.com',
    timeout: 10000,
    readTimeout: 10000,
    loginType: 'BASIC',
    userName: 'foo',
    password: 'some pass'
  ],
  [
    name: 'moar jira',
    url: 'http://example.com',
    timeout: 10000,
    readTimeout: 10000,
    loginType: 'OAUTH',
    consumerKey: 'my consumer key',
    privateKey: 'my private key',
    secret: 'super secret',
    token: 'my token'
  ]
] as JSONArray

//get global Jenkins configuration
JiraStepsConfig.ConfigDescriptorImpl config = Jenkins.instance.getExtensionList(JiraStepsConfig.ConfigDescriptorImpl.class)[0]

ArrayList<Site> sites = new ArrayList<Site>()

//configure new sites from the above JSONArray
sitesConf.each { s ->
  String loginType = s.optString('loginType', '').toUpperCase()
  if(loginType in ['BASIC', 'OAUTH']) {
    Site site = new Site(s.optString('name',''), new URL(s.optString('url', '')), s.optString('loginType', ''), s.optInt('timeout', 10000))
    if(loginType == 'BASIC') {
      site.setUserName(s.optString('userName', ''))
      site.setPassword(s.optString('password', ''))
      site.setReadTimeout(s.optInt('readTimeout', 10000))
    } else { //loginType is OAUTH
      site.setConsumerKey(s.optString('consumerKey', ''))
      site.setPrivateKey(s.optString('privateKey', ''))
      site.setSecret(s.optString('secret', ''))
      site.setToken(s.optString('token', ''))
      site.setReadTimeout(s.optInt('readTimeout', 10000))
    }

    sites.add(site)
  }
}

//set our defined sites
config.setSites(sites.toArray(new Site[0]))

//persist configuration to disk as XML
config.save()

or via Configuration as Code plugin

unclassified:
  jiraStepsConfig:
    sites:
    - name: 'another'
      url: 'http://example.com'
      timeout: 10000
      readTimeout: 10000
      loginType: 'BASIC'
      userName: 'foo'
      password: 'some pass'
    - name: 'moar jira'
      url: 'http://example.com'
      timeout: 10000
      readTimeout: 10000
      loginType: 'OAUTH'
      consumerKey: 'my consumer key'
      privateKey: 'my private key'
      secret: 'super secret'
      token: 'my token'

for (plugin in ["ant",
    "artifactdeployer",
    "build-failure-analyzer",
    "build-name-setter",
    "build-pipeline-plugin",
    "build-timeout",
    "claim",
    "clone-workspace-scm",
    "cobertura",
    "collapsing-console-sections",
    "conditional-buildstep",
    "configurationslicing",
    "copy-to-slave",
    "credentials",
    "cvs",
    "disk-usage",
    "ec2",
    "email-ext",
    "external-monitor-job",
    "git",
    "git-client",
    "global-build-stats",
    "gravatar",
    "groovy-postbuild",
    "javadoc",
    "jobConfigHistory",
    "ldap",
    "mailer",
    "mask-passwords",
    "maven-plugin",
    "openid",
    "pam-auth",
    "parameterized-trigger",
    "run-condition",
    "shelve-project-plugin",
    "ssh-credentials",
    "ssh-slaves",
    "subversion",
    "svn-release-mgr",
    "token-macro",
    "translation",
    "view-job-filters",
    "ws-cleanup"]) {
  e = Hudson.instance.updateCenter.getPlugin(plugin).deploy().get().getError()
  if (e != null)
    println e.message
}

import jenkins.model.*
import java.util.logging.Logger

def logger = Logger.getLogger("")
def installed = false
def initialized = false

def pluginParameter="gitlab-plugin hipchat swarm"
def plugins =pluginParameter.split()
logger.info("" + plugins)
def instance =Jenkins.getInstance()
def pm = instance.getPluginManager()
def uc =instance.getUpdateCenter()
uc.updateAllSites()

plugins.each {   logger.info("Checking " + it)   if
(!pm.getPlugin(it)) {
    logger.info("Looking UpdateCenter for " + it)
    if (!initialized) {
      uc.updateAllSites()
      initialized = true
    }
    def plugin = uc.getPlugin(it)
    if (plugin) {
      logger.info("Installing " + it)
        plugin.deploy()
      installed = true
    }   } }

if (installed)
   {
      logger.info("Plugins installed, initializing a   restart!")
       instance.save()
       instance.doSafeRestart()
 }

Jenkins search results missing /ci/ URL component

new File(System.getProperty("user.home"),'.nestedViewsSearch').createNewFile()

jenkins server info

println("Jenkins: ${Jenkins.instance.getVersion()}")
println("OS: ${System.getProperty('os.name')} - ${System.getProperty('os.version')}")
println("Java: ${System.getProperty('java.version')} - ${System.getProperty('java.vm.vendor')} (${System.getProperty('java.vm.name')})")

results matching ""

No results matching ""