references:

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:]

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()
  }
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'
    
  • install plugin

    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
    }
    
    • or

      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')})")
Copyright © marslo 2020-2023 all right reserved,powered by GitbookLast Modified: 2024-03-12 15:01:28

results matching ""

    No results matching ""