hudson.model.labels.LabelAtom Java Examples

@Override
public Boolean call() throws Throwable {
    final Jenkins jenkins = Jenkins.getInstance();

    // prepare job
    final FreeStyleProject project = jenkins.createProject(FreeStyleProject.class, "freestyle-project");
    final Shell env = new Shell("env");
    project.getBuildersList().add(env);
    project.setAssignedLabel(new LabelAtom(DOCKER_CLOUD_LABEL));
    project.save();

    LOG.trace("trace test.");
    project.scheduleBuild(new TestCause());

    // image pull may take time
    waitUntilNoActivityUpTo(jenkins, 10 * 60 * 1000);

    final FreeStyleBuild lastBuild = project.getLastBuild();
    assertThat(lastBuild, not(nullValue()));
    assertThat(lastBuild.getResult(), is(Result.SUCCESS));

    assertThat(getLog(lastBuild), Matchers.containsString(TEST_VALUE));
    assertThat(getLog(lastBuild), Matchers.containsString(CLOUD_ID + "=" + DOCKER_CLOUD_NAME));

    return true;
}
 

@Test
public void provision_oneagent() throws Exception {

    List<ECSTaskTemplate> templates = new ArrayList<>();
    templates.add(getTaskTemplate("my-template","label"));

    ECSCloud sut = new ECSCloud("mycloud", "", "mycluster");
    sut.setTemplates(templates);
    sut.setRegionName("eu-west-1");
    sut.setJenkinsUrl("http://jenkins.local");
    sut.setSlaveTimeoutInSeconds(5);
    sut.setRetentionTimeout(5);
    Collection<PlannedNode> plannedNodes = sut.provision(new LabelAtom("label"), 1);

    Assert.assertEquals(1, plannedNodes.size());
}
 

@Test
public void canProvision_unknownLabel_returnsFalse() throws Exception {

    List<ECSTaskTemplate> templates = new ArrayList<>();

    ECSCloud sut = new ECSCloud("mycloud", "", "mycluster");
    sut.setTemplates(templates);
    sut.setRegionName("eu-west-1");
    sut.setJenkinsUrl("http://jenkins.local");
    sut.setSlaveTimeoutInSeconds(5);
    sut.setRetentionTimeout(5);

    boolean canProvision = sut.canProvision(new LabelAtom("unknownLabel"));

    Assert.assertFalse(canProvision);
}
 

@NonNull
@Override
public Set<Attribute<LabelAtom, ?>> describe() {
    return new HashSet<>(Arrays.asList(
        new Attribute<LabelAtom, String>("name", String.class)
            .getter(Label::getName),
        new MultivaluedAttribute<LabelAtom, LabelAtomProperty>("properties", LabelAtomProperty.class)
        .getter(labelAtom -> labelAtom.getProperties())
        .setter((labelAtom, properties) -> labelAtom.getProperties().addAll(properties))
    ));
}
 

private void mockNodeCreatingPart() {
    when(jenkins.getNodesObject()).thenReturn(mock(Nodes.class));

    ExtensionList labelFinder = mock(ExtensionList.class);
    when(labelFinder.iterator()).thenReturn(Collections.emptyIterator());
    PowerMockito.when(LabelFinder.all()).thenReturn(labelFinder);

    // mocking part of node creation process Jenkins.getInstance().getLabelAtom(l)
    when(jenkins.getLabelAtom(anyString())).thenReturn(new LabelAtom("mock-label"));
}
 

protected List<QueueTaskFuture> getQueueTaskFutures(int count) throws IOException {
    final LabelAtom label = new LabelAtom("momo");

    final List<QueueTaskFuture> rs = new ArrayList<>();
    for (int i = 0; i < count; i++) {
        final FreeStyleProject project = j.createFreeStyleProject();
        project.setAssignedLabel(label);
        project.getBuildersList().add(Functions.isWindows() ? new BatchFile("Ping -n " + JOB_SLEEP_TIME + " 127.0.0.1 > nul") : new Shell("sleep " + JOB_SLEEP_TIME));
        rs.add(project.scheduleBuild2(0));
    }
    return rs;
}
 

@Before
public void setup() {
    Set<LabelAtom> labels = Collections.singleton(label);
    Mockito.when(label.matches(Mockito.anyCollectionOf(LabelAtom.class))).thenReturn(true);
    Mockito.when(slaveTemplate.createSlaveName()).thenReturn("slave-1", "slave-2", "slave-3");
    Mockito.when(slaveTemplate.getNumExecutors()).thenReturn(1);
    Mockito.when(slaveTemplate.getLabelSet()).thenReturn(labels);
}
 

@Test
@ConfiguredWithCode("ConfigureLabels.yml")
public void shouldImportLabelAtoms() {
    LabelAtom label1 = Jenkins.get().getLabelAtom("label1");
    assertNotNull(label1);
    assertThat(label1.getProperties(), hasSize(2));
    assertEquals(2, label1.getProperties().get(TestProperty.class).value);
    assertEquals(4, label1.getProperties().get(AnotherTestProperty.class).otherProperty);

    LabelAtom label2 = Jenkins.get().getLabelAtom("label2");
    assertNotNull(label2);
    assertThat(label2.getProperties(), hasSize(1));
    assertEquals(3, label2.getProperties().get(TestProperty.class).value);
}
 

@Test
public void testCanProvisionMultipleLabels() {
    KafkaKubernetesCloud cloud = new KafkaKubernetesCloud("kafka-kubernetes");
    cloud.setLabel("label1 label2");
    assertThat(cloud.canProvision(new LabelAtom("label1")), is(true));
    assertThat(cloud.canProvision(new LabelAtom("label3")), is(false));
}
 

@Test
public void testCanProvisionSingleLabel() {
    KafkaKubernetesCloud cloud = new KafkaKubernetesCloud("kafka-kubernetes");
    cloud.setLabel("test");
    assertThat(cloud.canProvision(null), is(false));
    assertThat(cloud.canProvision(new LabelAtom("test")), is(true));
    assertThat(cloud.canProvision(new LabelAtom("wrong")), is(false));
}
 

@Test
public void testProvisionCreateThenTerminatePod() throws Exception {
    KafkaKubernetesCloud cloud = new KafkaKubernetesCloud("kafka-kubernetes");
    cloud.setServerUrl(k.getMockServer().url("/").toString());
    cloud.setSkipTlsVerify(true);
    j.jenkins.clouds.add(cloud);

    Collection<NodeProvisioner.PlannedNode> provisionedNodes = cloud.provision(new LabelAtom("test"), 1);
    assertThat(provisionedNodes, hasSize(1));
    KafkaCloudSlave agent = (KafkaCloudSlave) provisionedNodes.iterator().next().future.get();
    TaskListener listener = new LogTaskListener(Logger.getLogger(KafkaKubernetesCloudTest.class.getName()), Level.INFO);
    PodResource<Pod, DoneablePod> pod = k.getClient().pods().inNamespace(cloud.getNamespace()).withName(agent.getNodeName());

    assertNull(pod.get());

    // Poll for pod creation
    j.jenkins.addNode(agent);
    final int TIMEOUT = 30;
    for(int i = 0; i < TIMEOUT; i++) {
        if (pod.get() != null) break;
        TimeUnit.SECONDS.sleep(1);
    }
    assertNotNull(pod.get());

    agent._terminate(listener);
    assertNull(pod.get());
}
 

/**
 * Creates an {@link DumbSlave agent} with the specified label.
 *
 * @param label
 *         the label of the agent
 *
 * @return the agent
 */
@SuppressWarnings("illegalcatch")
protected Slave createAgent(final String label) {
    try {
        return getJenkins().createOnlineSlave(new LabelAtom(label));
    }
    catch (Exception e) {
        throw new AssertionError(e);
    }
}
 

@Nonnull
public Set<LabelAtom> getLabelSet() {
    return labelSet;
}
 

public Set<LabelAtom> getLabelSet() {
    return Label.parse(label);
}
 

@Nonnull
public Set<LabelAtom> getLabelSet() {
    return labelSet != null ? labelSet : Collections.emptySet();
}
 

@Override
public Label getAssignedLabel(@Nonnull SubTask task) {
    return new LabelAtom(uuid);
}
 

@Override
public Set<LabelAtom> getAssignedLabels() {
    final TreeSet<LabelAtom> labels = new TreeSet<>();
    labels.add(new LabelAtom(getLabelString()));
    return labels;
}
 

public Set<LabelAtom> getLabelSet() {
    return Label.parse(label);
}
 

@Test
public void should_successfully_resubmit_parametrized_task() throws Exception {
    EC2FleetCloud cloud = new EC2FleetCloud(null, null, "credId", null, "region",
            null, "fId", "momo", null, new LocalComputerConnector(j), false, false,
            0, 0, 10, 1, false, false,
            false, 0, 0, false,
            10, false);
    j.jenkins.clouds.add(cloud);

    List<QueueTaskFuture> rs = new ArrayList<>();
    final FreeStyleProject project = j.createFreeStyleProject();
    project.setAssignedLabel(new LabelAtom("momo"));
    project.addProperty(new ParametersDefinitionProperty(new StringParameterDefinition("number", "opa")));
    /*
    example of actions for project

    actions = {CopyOnWriteArrayList@14845}  size = 2
        0 = {ParametersAction@14853}
        safeParameters = {TreeSet@14855}  size = 0
        parameters = {ArrayList@14856}  size = 1
        0 = {StringParameterValue@14862} "(StringParameterValue) number='1'"
        value = "1"
        name = "number"
        description = ""
        parameterDefinitionNames = {ArrayList@14857}  size = 1
        0 = "number"
        build = null
        run = {FreeStyleBuild@14834} "parameter #14"
     */
    project.getBuildersList().add(Functions.isWindows() ? new BatchFile("Ping -n %number% 127.0.0.1 > nul") : new Shell("sleep ${number}"));

    rs.add(project.scheduleBuild2(0, new ParametersAction(new StringParameterValue("number", "30"))));

    System.out.println("check if zero nodes!");
    Assert.assertEquals(0, j.jenkins.getNodes().size());

    assertAtLeastOneNode();

    final Node node = j.jenkins.getNodes().get(0);
    assertQueueIsEmpty();

    System.out.println("disconnect node");
    node.toComputer().disconnect(new OfflineCause.ChannelTermination(new UnsupportedOperationException("Test")));

    assertLastBuildResult(Result.FAILURE, Result.ABORTED);

    node.toComputer().connect(true);
    assertNodeIsOnline(node);
    assertQueueAndNodesIdle(node);

    Assert.assertEquals(1, j.jenkins.getProjects().size());
    Assert.assertEquals(Result.SUCCESS, j.jenkins.getProjects().get(0).getLastBuild().getResult());
    Assert.assertEquals(2, j.jenkins.getProjects().get(0).getBuilds().size());

    cancelTasks(rs);
}
 

public Set<LabelAtom> getLabelSet() {
    return labelSet;
}
 

@Test
@ConfiguredWithReadme("ec2/README.md")
public void configure_ec2_cloud() throws Exception {
    final AmazonEC2Cloud ec2Cloud = (AmazonEC2Cloud) Jenkins.get().getCloud("ec2-ec2");
    assertNotNull(ec2Cloud);

    assertTrue(ec2Cloud.isUseInstanceProfileForCredentials());
    assertThat(ec2Cloud.getPrivateKey().getPrivateKey(), is("ADMIN123"));
    final List<SlaveTemplate> templates = ec2Cloud.getTemplates();
    assertThat(templates, hasSize(2));

    SlaveTemplate slaveTemplate = templates.get(0);
    assertThat(slaveTemplate.getDisplayName(), containsString("Auto configured EC2 Agent Small"));
    assertFalse(slaveTemplate.getAssociatePublicIp());
    assertFalse(slaveTemplate.isConnectBySSHProcess());
    assertFalse(slaveTemplate.deleteRootOnTermination);
    assertFalse(slaveTemplate.ebsOptimized);
    assertFalse(slaveTemplate.monitoring);
    assertFalse(slaveTemplate.stopOnTerminate);
    assertFalse(slaveTemplate.getUseDedicatedTenancy());
    assertFalse(slaveTemplate.useEphemeralDevices);
    assertThat(slaveTemplate.type, is(InstanceType.T2Small));
    assertThat(slaveTemplate.getAmi(), equalTo("ami-0c6bb742864ffa3f3"));
    assertThat(slaveTemplate.getLabelString(), containsString("Small"));
    assertThat(slaveTemplate.getLabelSet(), is(notNullValue()));
    assertThat(slaveTemplate.remoteFS, equalTo("/home/ec2-user"));
    assertThat(slaveTemplate.getRemoteAdmin(), equalTo("ec2-user"));
    assertThat(slaveTemplate.zone, equalTo("us-east-1"));
    assertThat(slaveTemplate.getSecurityGroupString(), equalTo("some-group"));

    // fails here without mode specified
    assertTrue(ec2Cloud.canProvision(new LabelAtom("Small")));

    // Checks that the AMI type is Unix and configured
    AMITypeData amiType = slaveTemplate.getAmiType();
    assertTrue(amiType.isUnix());
    assertTrue(amiType instanceof UnixData);
    UnixData unixData = (UnixData) amiType;
    assertThat(unixData.getRootCommandPrefix(), equalTo("sudo"));
    assertThat(unixData.getSlaveCommandPrefix(), equalTo("sudo -u jenkins"));
    assertThat(unixData.getSshPort(), equalTo("61120"));


    slaveTemplate = templates.get(1);
    assertThat(slaveTemplate.getDisplayName(), containsString("Auto configured EC2 Agent Large"));
    assertFalse(slaveTemplate.getAssociatePublicIp());
    assertFalse(slaveTemplate.isConnectBySSHProcess());
    assertFalse(slaveTemplate.deleteRootOnTermination);
    assertFalse(slaveTemplate.ebsOptimized);
    assertFalse(slaveTemplate.monitoring);
    assertFalse(slaveTemplate.stopOnTerminate);
    assertFalse(slaveTemplate.getUseDedicatedTenancy());
    assertFalse(slaveTemplate.useEphemeralDevices);
    assertThat(slaveTemplate.type, is(InstanceType.T2Xlarge));
    assertThat(slaveTemplate.getAmi(), equalTo("ami-0c6bb742864ffa3f3"));
    assertThat(slaveTemplate.getLabelString(), containsString("Large"));
    assertThat(slaveTemplate.getLabelSet(), is(notNullValue()));
    assertThat(slaveTemplate.remoteFS, equalTo("/home/ec2-user"));
    assertThat(slaveTemplate.getRemoteAdmin(), equalTo("ec2-user"));
    assertThat(slaveTemplate.zone, equalTo("us-east-1"));
    assertThat(slaveTemplate.getSecurityGroupString(), equalTo("some-group"));

    // fails here without mode specified
    assertTrue(ec2Cloud.canProvision(new LabelAtom("Large")));

    // Checks that the AMI type is Unix and configured
    amiType = slaveTemplate.getAmiType();
    assertTrue(amiType.isUnix());
    assertTrue(amiType instanceof UnixData);
    unixData = (UnixData) amiType;
    assertThat(unixData.getRootCommandPrefix(), equalTo("sudo"));
    assertThat(unixData.getSlaveCommandPrefix(), equalTo("sudo -u jenkins"));
    assertThat(unixData.getSshPort(), equalTo("61120"));
}
 

@NonNull
@Override
public Set<Attribute<Jenkins,?>> describe() {
    final Set<Attribute<Jenkins,?>> attributes = super.describe();

    // Add remoting security, all legwork will be done by a configurator
    attributes.add(new Attribute<Jenkins, AdminWhitelistRule>("remotingSecurity", AdminWhitelistRule.class)
            .getter( j -> j.getInjector().getInstance(AdminWhitelistRule.class) )
            .setter( noop() ));

    // Override "nodes" getter so we don't export Nodes registered by Cloud plugins
    Attribute.<Jenkins, List<Node>>get(attributes, "nodes").ifPresent(attribute ->
            attribute
                    .getter(jenkins -> jenkins.getNodes().stream()
                            .filter(node -> !isCloudNode(node))
                            .collect(Collectors.toList()))
                    .setter((jenkins, configuredNodes) -> {
                        List<String> configuredNodesNames = configuredNodes.stream()
                                .map(Node::getNodeName)
                                .collect(Collectors.toList());
                        List<Node> nodesToKeep = jenkins.getNodes().stream()
                                .filter(node -> !configuredNodesNames.contains(node.getNodeName()))
                                .filter(this::isCloudNode)
                                .collect(Collectors.toList());
                        nodesToKeep.addAll(configuredNodes);
                        jenkins.setNodes(nodesToKeep);
                    })
    );

    // Add updateCenter, all legwork will be done by a configurator
    attributes.add(new Attribute<Jenkins, UpdateCenter>("updateCenter", UpdateCenter.class)
            .getter(Jenkins::getUpdateCenter)
            .setter( noop() ));

    attributes.add(new MultivaluedAttribute<Jenkins, LabelAtom>("labelAtoms", LabelAtom.class)
            .getter(jenkins -> jenkins.getLabelAtoms())
            .setter((jenkins, labelAtoms) -> {
                for (LabelAtom labelAtom : labelAtoms) {
                    // Get or create a LabelAtom instance
                    LabelAtom atom = jenkins.getLabelAtom(labelAtom.getName());

                    if (atom != null) {
                        atom.getProperties().clear();
                        atom.getProperties().addAll(labelAtom.getProperties());
                    }
                }
            })
    );

    attributes.add(new Attribute<Jenkins, ProxyConfiguration>("proxy", ProxyConfiguration.class)
            .getter( j -> j.proxy)
            .setter((o, v) -> o.proxy = v));

    return attributes;
}
 

@Override
protected LabelAtom instance(Mapping mapping, ConfigurationContext context) throws ConfiguratorException {
    return new LabelAtom(mapping.getScalarValue("name"));
}
 

@Override
public Class<LabelAtom> getTarget() {
    return LabelAtom.class;
}
 

@Test
public void testProvisionWorkloadSize() {
    KafkaKubernetesCloud cloud = new KafkaKubernetesCloud("kafka-kubernetes");
    Collection<NodeProvisioner.PlannedNode> nodes = cloud.provision(new LabelAtom("test"), 200);
    assertThat(nodes, hasSize(200));
}
 

public Set<LabelAtom> getLabelSet() {
    return Label.parse(label);
}