Question

我想在所有UNIX从属服务器上运行相同的shell命令（非常简单的shell命令，如ls）通过使用master的脚本控制台连接到master。

我怎么能用groovy做到这一点？

想做类似的事情：Display Information About Nodes 但是我想在每个从站上运行一些简单的UNIX命令并打印结果，而不是显示信息。

Answer 1

import hudson.util.RemotingDiagnostics;

print_ip = 'println InetAddress.localHost.hostAddress';
print_hostname = 'println InetAddress.localHost.canonicalHostName';

// here it is - the shell command, uname as example 
uname = 'def proc = "uname -a".execute(); proc.waitFor(); println proc.in.text';

for (slave in hudson.model.Hudson.instance.slaves) {
    println slave.name;
    println RemotingDiagnostics.executeGroovy(print_ip, slave.getChannel());
    println RemotingDiagnostics.executeGroovy(print_hostname, slave.getChannel());
    println RemotingDiagnostics.executeGroovy(uname, slave.getChannel());
}

Answer 2

直到最后，我不使用*搜索代理，而是读取并解析它们的名称。例如，如果我想在每个名称为LINUX的代理上运行作业，我将执行下一步：

for (aSlave in hudson.model.Hudson.instance.slaves)
{
   /* take into account just agents with LINUX in name*/
   AGENT_NAME = aSlave.name
   if ( AGENT_NAME.contains('LINUX') )
   {
      /* you can check also if the agent is online or other attributes */

      /* Add agent name as label of the agent */ 
      AGENT_LABELS = aSlave.getLabelString() + " " + AGENT_NAME
      aSlave.setLabelString(AGENT_LABELS)


      /* For each found agent, create a job that will run on it */
      job('My_job_name_' + AGENT_NAME)
      {
          label(AGENT_NAME)
          steps {
               /* Do whatever you want here. 
                  This job will run just on this specific agent (due to label set) */
           }
      } 
   } /* end if */
} /* end for */  

/* If you want to run all jobs in parallel (every job on a specific agent), you can save all found agents in a list and then create one more pipeline job that will contain next line :

   ' parallel {
      b0: {build 'My_job_name_' + AGENT_NAME_LIST[0]},
      b1: {build 'My_job_name_' + AGENT_NAME_LIST[1]},
      ....
    }
    fastfail: false '

Answer 3

管道看起来像这样：

stages  {
      stage('Checkout repo') {
         steps  {
            //checkout what I need
         }
      }
      stage('Generate Jobs')  {
         steps  {
            jobDsl targets:'generate_projects.groovy',
         }
      }
      stage('Build Projects')  {
         steps  {
            build job: "build-all",
            propagate: true,
            wait: true
         }
      }
   }

然后是文件generate_projects.groovy，其中实际的DSL生成是：

for (agent in hudson.model.Hudson.instance.slaves) {
   if (!agent.getComputer().isOffline())  { // check that agent is not offline
      node = jenkins.model.Jenkins.instance.getNode(agent.name)  // get agent name
      agentIPs = node.computer.getChannel().call(new ListPossibleNames())
      agentIP = agentIPs[0]  // get agent IP
      
      //Create a job that will run on that specific agent
      jobName = FOLDER + '/<Job_name>' + agent.name     // need to create different names
      job(jobName)
      {
         label(agent.name)
         steps
         {
             shell(<shell script or commands that you want to run>)
         }
      }
   }
}

除了上述作业之外，您还需要保留一份已生成的作业列表，并将其所有元素添加到“全部构建”管道作业中，如下所示：

parallel(
   b0: {build '<Job_name>' + agent.name'},
   b1: {build '<Job_name>' + agent.name'},
   b2: {build '<Job_name>' + agent.name'},
   .....
)
failFast: false

因此，当您运行管道时，将为每个代理创建一个作业，并且所有新创建的作业将并行运行。我用它来更新设置方案。

Answer 4

相当旧的线程。

我以另一种方式处理了同样的情况。我有正在做下一阶段的管道作业： -首先，它使用以下方式检查在线代理（由于它们是物理机，因此可能会宕机）：“（（在hudson.model.Hudson.instance.slaves中的从属）...”） -下一步是使用DSL插件和list_of_agents.each为每个找到的代理创建作业。除了每个在线代理的工作之外，它还创建了一个可以并行运行所有工作的工作。当然，新创建的作业包含我要在代理上运行的命令。当我运行管道时，在所有代理上将运行相同的脚本/命令，并将输出返回到主管道作业。

通过Masters的脚本控制台在所有Jenkins从站上运行远程命令

4 个答案: