diff options
Diffstat (limited to 'calamus-jenkins-plugin/src/main/java')
3 files changed, 242 insertions, 0 deletions
diff --git a/calamus-jenkins-plugin/src/main/java/org/jenkinsci/plugins/calamus/HelloWorldBuilder.java b/calamus-jenkins-plugin/src/main/java/org/jenkinsci/plugins/calamus/HelloWorldBuilder.java new file mode 100644 index 0000000..5844a26 --- /dev/null +++ b/calamus-jenkins-plugin/src/main/java/org/jenkinsci/plugins/calamus/HelloWorldBuilder.java @@ -0,0 +1,152 @@ +package org.jenkinsci.plugins.calamus; + +import hudson.Launcher; +import hudson.Extension; +import hudson.util.FormValidation; +import hudson.model.AbstractBuild; +import hudson.model.BuildListener; +import hudson.model.AbstractProject; +import hudson.tasks.Builder; +import hudson.tasks.BuildStepDescriptor; +import net.sf.json.JSONObject; +import org.kohsuke.stapler.DataBoundConstructor; +import org.kohsuke.stapler.StaplerRequest; +import org.kohsuke.stapler.QueryParameter; + +import javax.servlet.ServletException; +import java.io.IOException; + +/** + * Sample {@link Builder}. + * + * <p> + * When the user configures the project and enables this builder, + * {@link DescriptorImpl#newInstance(StaplerRequest)} is invoked + * and a new {@link HelloWorldBuilder} is created. The created + * instance is persisted to the project configuration XML by using + * XStream, so this allows you to use instance fields (like {@link #name}) + * to remember the configuration. + * + * <p> + * When a build is performed, the {@link #perform(AbstractBuild, Launcher, BuildListener)} + * method will be invoked. + * + * @author Kohsuke Kawaguchi + */ +public class HelloWorldBuilder extends Builder { + + private final String name; + + // Fields in config.jelly must match the parameter names in the "DataBoundConstructor" + @DataBoundConstructor + public HelloWorldBuilder(String name) { + this.name = name; + } + + /** + * We'll use this from the <tt>config.jelly</tt>. + */ + public String getName() { + return name; + } + + @Override + public boolean perform(AbstractBuild build, Launcher launcher, BuildListener listener) { + // This is where you 'build' the project. + // Since this is a dummy, we just say 'hello world' and call that a build. + + // This also shows how you can consult the global configuration of the builder + if (getDescriptor().getUseFrench()) + listener.getLogger().println("Bonjour, "+name+"!"); + else + listener.getLogger().println("Hello, "+name+"!"); + return true; + } + + // Overridden for better type safety. + // If your plugin doesn't really define any property on Descriptor, + // you don't have to do this. + @Override + public DescriptorImpl getDescriptor() { + return (DescriptorImpl)super.getDescriptor(); + } + + /** + * Descriptor for {@link HelloWorldBuilder}. Used as a singleton. + * The class is marked as public so that it can be accessed from views. + * + * <p> + * See <tt>src/main/resources/hudson/plugins/hello_world/HelloWorldBuilder/*.jelly</tt> + * for the actual HTML fragment for the configuration screen. + */ + @Extension // This indicates to Jenkins that this is an implementation of an extension point. + public static final class DescriptorImpl extends BuildStepDescriptor<Builder> { + /** + * To persist global configuration information, + * simply store it in a field and call save(). + * + * <p> + * If you don't want fields to be persisted, use <tt>transient</tt>. + */ + private boolean useFrench; + + /** + * In order to load the persisted global configuration, you have to + * call load() in the constructor. + */ + public DescriptorImpl() { + load(); + } + + /** + * Performs on-the-fly validation of the form field 'name'. + * + * @param value + * This parameter receives the value that the user has typed. + * @return + * Indicates the outcome of the validation. This is sent to the browser. + */ + public FormValidation doCheckName(@QueryParameter String value) + throws IOException, ServletException { + if (value.length() == 0) + return FormValidation.error("Please set a name"); + if (value.length() < 4) + return FormValidation.warning("Isn't the name too short?"); + return FormValidation.ok(); + } + + public boolean isApplicable(Class<? extends AbstractProject> aClass) { + // Indicates that this builder can be used with all kinds of project types + return true; + } + + /** + * This human readable name is used in the configuration screen. + */ + public String getDisplayName() { + return "Say hello world"; + } + + @Override + public boolean configure(StaplerRequest req, JSONObject formData) throws FormException { + // To persist global configuration information, + // set that to properties and call save(). + useFrench = formData.getBoolean("useFrench"); + // ^Can also use req.bindJSON(this, formData); + // (easier when there are many fields; need set* methods for this, like setUseFrench) + save(); + return super.configure(req,formData); + } + + /** + * This method returns true if the global configuration says we should speak French. + * + * The method name is bit awkward because global.jelly calls this method to determine + * the initial state of the checkbox by the naming convention. + */ + public boolean getUseFrench() { + return useFrench; + } + } +} + diff --git a/calamus-jenkins-plugin/src/main/java/org/jenkinsci/plugins/calamus/JbpmRunListener.java b/calamus-jenkins-plugin/src/main/java/org/jenkinsci/plugins/calamus/JbpmRunListener.java new file mode 100644 index 0000000..2376516 --- /dev/null +++ b/calamus-jenkins-plugin/src/main/java/org/jenkinsci/plugins/calamus/JbpmRunListener.java @@ -0,0 +1,42 @@ +package org.jenkinsci.plugins.calamus; + +import hudson.Extension; +import hudson.model.Build; +import hudson.model.TaskListener; +import hudson.model.listeners.RunListener; + +import javax.annotation.Nonnull; + +@Extension +public class JbpmRunListener extends RunListener<Build> { + + private final MqClient mqClient; + + public JbpmRunListener() { + super(Build.class); + + System.out.println("JbpmRunListener.JbpmRunListener"); + + mqClient = new MqClient("tcp://localhost:61616"); + } + + @Override + public void onCompleted(Build build, @Nonnull TaskListener listener) { + System.out.println("JbpmRunListener.onCompleted"); + System.out.println("build = " + build); + + System.out.println("build variables"); + for (Object o : build.getBuildVariables().entrySet()) { + System.out.println(o); + } + + mqClient.sendMessage(build.getProject().getName(), build.getNumber(), build.getResult().toString()); + +// Jenkins jenkins = Jenkins.getInstance(); +// List<AbstractProject> projects = jenkins.getAllItems(AbstractProject.class); +// for (AbstractProject project : projects) { +// System.out.println("project.getPronoun() = " + project.getPronoun()); +// System.out.println("project.getName() = " + project.getName()); +// } + } +} diff --git a/calamus-jenkins-plugin/src/main/java/org/jenkinsci/plugins/calamus/MqClient.java b/calamus-jenkins-plugin/src/main/java/org/jenkinsci/plugins/calamus/MqClient.java new file mode 100644 index 0000000..6ca4264 --- /dev/null +++ b/calamus-jenkins-plugin/src/main/java/org/jenkinsci/plugins/calamus/MqClient.java @@ -0,0 +1,48 @@ +package org.jenkinsci.plugins.calamus; + +import org.apache.activemq.ActiveMQConnectionFactory; + +import javax.jms.Connection; +import javax.jms.DeliveryMode; +import javax.jms.Destination; +import javax.jms.JMSException; +import javax.jms.MapMessage; +import javax.jms.MessageProducer; +import javax.jms.Session; + +import static javax.jms.Session.AUTO_ACKNOWLEDGE; + +public class MqClient { + + ActiveMQConnectionFactory connectionFactory; + + public MqClient(String brokerUrl) { + this.connectionFactory = new ActiveMQConnectionFactory(brokerUrl); + } + + public void sendMessage(String jobName, int buildNumber, String result) { + try { + Connection connection = connectionFactory.createConnection(); + connection.start(); + + Session session = connection.createSession(false, AUTO_ACKNOWLEDGE); + + Destination destination = session.createQueue("jenkins.build-result"); + + MessageProducer producer = session.createProducer(destination); + producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT); + + MapMessage message = session.createMapMessage(); + message.setString("jobName", jobName); + message.setInt("buildNumber", buildNumber); + message.setString("result", result); + + producer.send(message); + + session.close(); + connection.close(); + } catch (JMSException e) { + e.printStackTrace(); + } + } +} |