tricky
references:
DSL
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
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.model.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
import hudson.node_monitors.*
import hudson.slaves.*
import java.util.concurrent.*
jenkins = jenkins.model.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 "\nChecking 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:
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()
}[!TIP] or using
t.stop()instead oft.interrupt()Thread.getAllStackTraces().keySet().each() { t -> if ( t.getName()=="YOUR THREAD NAME" ) { t.interrupt(); } }
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.model.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'[ "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" ].each { plugin -> 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.model.Jenkins.instance 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() }
new File(System.getProperty("user.home"),'.nestedViewsSearch').createNewFile()println( "Groovy: ${GroovySystem.version}" )
println( "Jenkins: ${jenkins.model.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')})" )[!NOTE|label:references:]
import hudson.tasks.test.AbstractTestResultAction
@NonCPS
def testStatuses() {
def testStatus = ""
AbstractTestResultAction testResultAction = currentBuild.rawBuild.getAction(AbstractTestResultAction.class)
if ( testResultAction != null ) {
def total = testResultAction.totalCount
def failed = testResultAction.failCount
def skipped = testResultAction.skipCount
def passed = total - failed - skipped
testStatus = "Test Status:\n Passed: ${passed}, Failed: ${failed} ${testResultAction.failureDiffString}, Skipped: ${skipped}"
if ( failed == 0 ) {
currentBuild.result = 'SUCCESS'
}
}
return testStatus
}Last updated