├── plugin
    ├── src
    │   └── main
    │   │   ├── resources
    │   │       └── index.jelly
    │   │   ├── webapp
    │   │       ├── activiti-logo.xcf
    │   │       └── images
    │   │       │   ├── 24x24
    │   │       │       └── activiti.png
    │   │       │   └── 48x48
    │   │       │       └── activiti.png
    │   │   └── java
    │   │       └── org
    │   │           └── jenkinsci
    │   │               └── plugins
    │   │                   └── activiti_explorer
    │   │                       ├── XmlPatcher.java
    │   │                       └── ActivitiExplorer.java
    └── pom.xml
├── dto
    ├── src
    │   └── main
    │   │   └── java
    │   │       └── org
    │   │           └── jenkinsci
    │   │               └── plugins
    │   │                   └── activiti_explorer
    │   │                       └── dto
    │   │                           └── UserDTO.java
    └── pom.xml
├── activiti-explorer-override
    ├── src
    │   └── main
    │   │   └── java
    │   │       └── org
    │   │           └── jenkinsci
    │   │               └── plugins
    │   │                   └── jenkow
    │   │                       └── activiti
    │   │                           └── override
    │   │                               ├── JenkinsMainMenuBar.java
    │   │                               ├── JenkinsManagementMenuBar.java
    │   │                               ├── ExplorerApp2.java
    │   │                               ├── JenkinsProcessEngineFactory.java
    │   │                               ├── JenkinsComponentFactories.java
    │   │                               ├── ServletContextDataSource.java
    │   │                               ├── JenkinsUser.java
    │   │                               └── JenkinsLoginHandler.java
    └── pom.xml
└── pom.xml


/plugin/src/main/resources/index.jelly:
--------------------------------------------------------------------------------
1 | <div>
2 |   Embeds Activiti Explorer inside Jenkins
3 | </div>
4 | 


--------------------------------------------------------------------------------
/plugin/src/main/webapp/activiti-logo.xcf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jenkinsci/activiti-explorer-plugin/master/plugin/src/main/webapp/activiti-logo.xcf


--------------------------------------------------------------------------------
/plugin/src/main/webapp/images/24x24/activiti.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jenkinsci/activiti-explorer-plugin/master/plugin/src/main/webapp/images/24x24/activiti.png


--------------------------------------------------------------------------------
/plugin/src/main/webapp/images/48x48/activiti.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jenkinsci/activiti-explorer-plugin/master/plugin/src/main/webapp/images/48x48/activiti.png


--------------------------------------------------------------------------------
/dto/src/main/java/org/jenkinsci/plugins/activiti_explorer/dto/UserDTO.java:
--------------------------------------------------------------------------------
 1 | package org.jenkinsci.plugins.activiti_explorer.dto;
 2 | 
 3 | /**
 4 |  * @author Kohsuke Kawaguchi
 5 |  */
 6 | public class UserDTO {
 7 |     public String id, firstName, lastName, fullName, email;
 8 | 
 9 |     public boolean isAdmin, isUser;
10 | }
11 | 


--------------------------------------------------------------------------------
/activiti-explorer-override/src/main/java/org/jenkinsci/plugins/jenkow/activiti/override/JenkinsMainMenuBar.java:
--------------------------------------------------------------------------------
 1 | package org.jenkinsci.plugins.jenkow.activiti.override;
 2 | 
 3 | import org.activiti.explorer.ui.alfresco.AlfrescoMainMenuBar;
 4 | import org.activiti.explorer.ui.mainlayout.MainMenuBar;
 5 | 
 6 | /**
 7 |  * Customize the main menu bar to get rid of the profile link
 8 |  *
 9 |  * @author Kohsuke Kawaguchi
10 |  * @see AlfrescoMainMenuBar
11 |  */
12 | public class JenkinsMainMenuBar extends MainMenuBar {
13 |     @Override
14 |     protected boolean useProfile() {
15 |         // profile is not editable
16 |         return false;
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/activiti-explorer-override/src/main/java/org/jenkinsci/plugins/jenkow/activiti/override/JenkinsManagementMenuBar.java:
--------------------------------------------------------------------------------
 1 | package org.jenkinsci.plugins.jenkow.activiti.override;
 2 | 
 3 | import org.activiti.explorer.ui.alfresco.AlfrescoManagementMenuBar;
 4 | import org.activiti.explorer.ui.management.ManagementMenuBar;
 5 | 
 6 | /**
 7 |  * Get rid of the users and groups UI because we won't let those things edited in Activiti
 8 |  *
 9 |  * @author Kohsuke Kawaguchi
10 |  * @see AlfrescoManagementMenuBar
11 |  */
12 | public class JenkinsManagementMenuBar extends ManagementMenuBar {
13 |     protected void addUsersToolbarEntry() {
14 |     }
15 | 
16 |     protected void addGroupToolbarEntry() {
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/dto/pom.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
 3 |   <modelVersion>4.0.0</modelVersion>
 4 | 
 5 |   <parent>
 6 |     <groupId>org.jenkins-ci.plugins</groupId>
 7 |     <artifactId>activiti-explorer-plugin-parent</artifactId>
 8 |     <version>1.0-SNAPSHOT</version>
 9 |   </parent>
10 | 
11 |   <artifactId>activiti-explorer-dto</artifactId>
12 |   <description>Serializable objects that are passed between AE and Jenkins to carry information back and forth</description>
13 | 
14 |   <!--
15 |     Because these classes need to be loaded both in Jenkins and AE,
16 |     we cannot depend on either.
17 |   -->
18 | </project>
19 | 


--------------------------------------------------------------------------------
/activiti-explorer-override/src/main/java/org/jenkinsci/plugins/jenkow/activiti/override/ExplorerApp2.java:
--------------------------------------------------------------------------------
 1 | package org.jenkinsci.plugins.jenkow.activiti.override;
 2 | 
 3 | import org.activiti.explorer.ExplorerApp;
 4 | 
 5 | import javax.servlet.http.HttpServletRequest;
 6 | import javax.servlet.http.HttpServletResponse;
 7 | 
 8 | /**
 9 |  * @author Kohsuke Kawaguchi
10 |  */
11 | public class ExplorerApp2 extends ExplorerApp {
12 |     @Override
13 |     public void onRequestStart(HttpServletRequest request, HttpServletResponse response) {
14 |         // AE caches the logged in user into a session, which means it won't notice when the user logs out in Jenkins
15 |         // or logs in. Our JenkinsLoginHandler is efficient, no need to cache this.
16 |         setUser(null);
17 | 
18 |         super.onRequestStart(request, response);
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/activiti-explorer-override/src/main/java/org/jenkinsci/plugins/jenkow/activiti/override/JenkinsProcessEngineFactory.java:
--------------------------------------------------------------------------------
 1 | package org.jenkinsci.plugins.jenkow.activiti.override;
 2 | 
 3 | import org.activiti.engine.ProcessEngine;
 4 | import org.springframework.beans.factory.FactoryBean;
 5 | import org.springframework.web.context.ServletContextAware;
 6 | 
 7 | import javax.servlet.ServletContext;
 8 | 
 9 | /**
10 |  * @author Kohsuke Kawaguchi
11 |  */
12 | public class JenkinsProcessEngineFactory implements FactoryBean<ProcessEngine>, ServletContextAware {
13 |     private ServletContext servletContext;
14 | 
15 |     @Override
16 |     public ProcessEngine getObject() throws Exception {
17 |         return (ProcessEngine)servletContext.getAttribute(ProcessEngine.class.getName());
18 |     }
19 | 
20 |     @Override
21 |     public Class<ProcessEngine> getObjectType() {
22 |         return ProcessEngine.class;
23 |     }
24 | 
25 |     @Override
26 |     public boolean isSingleton() {
27 |         return true;
28 |     }
29 | 
30 |     @Override
31 |     public void setServletContext(ServletContext servletContext) {
32 |         this.servletContext = servletContext;
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/activiti-explorer-override/src/main/java/org/jenkinsci/plugins/jenkow/activiti/override/JenkinsComponentFactories.java:
--------------------------------------------------------------------------------
 1 | package org.jenkinsci.plugins.jenkow.activiti.override;
 2 | 
 3 | import org.activiti.explorer.ComponentFactories;
 4 | import org.activiti.explorer.Environments;
 5 | import org.activiti.explorer.ui.custom.ToolBar;
 6 | import org.activiti.explorer.ui.mainlayout.MainMenuBarFactory;
 7 | import org.activiti.explorer.ui.management.ManagementMenuBarFactory;
 8 | 
 9 | /**
10 |  * More hook for injecting custom UI components.
11 |  *
12 |  * @author Kohsuke Kawaguchi
13 |  */
14 | public class JenkinsComponentFactories extends ComponentFactories {
15 |     public JenkinsComponentFactories() {
16 |         // TODO: send patch to Activiti to clean up this hack
17 |         factories.put(MainMenuBarFactory.class, new MainMenuBarFactory(){
18 |             @Override
19 |             protected Class getDefaultComponentClass() {
20 |                 return JenkinsMainMenuBar.class;
21 |             }
22 |         });
23 |         factories.put(ManagementMenuBarFactory.class, new ManagementMenuBarFactory() {
24 |             @Override
25 |             protected Class<? extends ToolBar> getDefaultComponentClass() {
26 |                 return JenkinsManagementMenuBar.class;
27 |             }
28 |         });
29 |         setEnvironment(Environments.ACTIVITI);
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/activiti-explorer-override/src/main/java/org/jenkinsci/plugins/jenkow/activiti/override/ServletContextDataSource.java:
--------------------------------------------------------------------------------
 1 | package org.jenkinsci.plugins.jenkow.activiti.override;
 2 | 
 3 | import org.springframework.beans.factory.FactoryBean;
 4 | import org.springframework.web.context.ServletContextAware;
 5 | 
 6 | import javax.servlet.ServletContext;
 7 | import javax.sql.DataSource;
 8 | 
 9 | /**
10 |  * Returns {@link DataSource} injected through {@link ServletContext} attribute.
11 |  *
12 |  * This is how the jenkow plugin passes in the {@link DataSource} to the embedded activiti explorer.
13 |  *
14 |  * @author Kohsuke Kawaguchi
15 |  */
16 | public class ServletContextDataSource implements FactoryBean, ServletContextAware {
17 |     private ServletContext servletContext;
18 | 
19 |     @Override
20 |     public void setServletContext(ServletContext servletContext) {
21 |         this.servletContext = servletContext;
22 |     }
23 | 
24 |     @Override
25 |     public Object getObject() throws Exception {
26 |         Object o = servletContext.getAttribute(ServletContextDataSource.class.getName());
27 |         if (o==null)
28 |             throw new IllegalStateException("ServletContext doesn't contain a DataSource");
29 |         return o;
30 |     }
31 | 
32 |     @Override
33 |     public Class<?> getObjectType() {
34 |         return DataSource.class;
35 |     }
36 | 
37 |     @Override
38 |     public boolean isSingleton() {
39 |         return true;
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/activiti-explorer-override/src/main/java/org/jenkinsci/plugins/jenkow/activiti/override/JenkinsUser.java:
--------------------------------------------------------------------------------
 1 | package org.jenkinsci.plugins.jenkow.activiti.override;
 2 | 
 3 | import org.activiti.explorer.identity.LoggedInUser;
 4 | import org.jenkinsci.plugins.activiti_explorer.dto.UserDTO;
 5 | 
 6 | /**
 7 |  * @author Kohsuke Kawaguchi
 8 |  */
 9 | public class JenkinsUser implements LoggedInUser {
10 |     private final UserDTO dto;
11 | 
12 |     public JenkinsUser(UserDTO dto) {
13 |         if (dto ==null)
14 |             throw new IllegalArgumentException("No information given");
15 |         this.dto = dto;
16 |     }
17 | 
18 |     public String getId() {
19 |         return dto.id;
20 |     }
21 | 
22 |     public String getFirstName() {
23 |         return dto.firstName;
24 |     }
25 | 
26 |     public String getLastName() {
27 |         return dto.lastName;
28 |     }
29 | 
30 |     public String getFullName() {
31 |         return dto.fullName;
32 |     }
33 | 
34 |     public String getPassword() {
35 |         return null;
36 |     }
37 | 
38 |     public boolean isAdmin() {
39 |         return dto.isAdmin;
40 |     }
41 | 
42 |     public boolean isUser() {
43 |         return dto.isUser;
44 |     }
45 | 
46 |     @Override
47 |     public int hashCode() {
48 |         return getId().hashCode();
49 |     }
50 | 
51 |     @Override
52 |     public boolean equals(Object obj) {
53 |         if (obj instanceof LoggedInUser)
54 |             return ((LoggedInUser)obj).getId().equals(getId());
55 |         return false;
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/activiti-explorer-override/pom.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
 3 |   <modelVersion>4.0.0</modelVersion>
 4 | 
 5 |   <parent>
 6 |     <groupId>org.jenkins-ci.plugins</groupId>
 7 |     <artifactId>activiti-explorer-plugin-parent</artifactId>
 8 |     <version>1.0-SNAPSHOT</version>
 9 |   </parent>
10 | 
11 |   <artifactId>activiti-explorer-override</artifactId>
12 |   <description>Additional code to be injected into Activiti Explorer to tweak its behaviour</description>
13 | 
14 |   <dependencies>
15 |     <dependency>
16 |       <groupId>org.springframework</groupId>
17 |       <artifactId>spring-beans</artifactId>
18 |       <version>3.1.2.RELEASE</version>
19 |       <scope>provided</scope>
20 |     </dependency>
21 |     <dependency>
22 |       <groupId>org.activiti</groupId>
23 |       <artifactId>activiti-engine</artifactId>
24 |       <version>${activiti.version}</version>
25 |       <scope>provided</scope>
26 |     </dependency>
27 |     <dependency>
28 |       <groupId>${project.groupId}</groupId>
29 |       <artifactId>activiti-explorer-dto</artifactId>
30 |       <version>${project.version}</version>
31 |     </dependency>
32 |     <dependency>
33 |       <groupId>org.activiti</groupId>
34 |       <artifactId>activiti-webapp-explorer2</artifactId>
35 |       <type>jar</type>
36 |       <version>${activiti.version}</version>
37 |       <scope>provided</scope>
38 |     </dependency>
39 |   </dependencies>
40 | </project>
41 | 


--------------------------------------------------------------------------------
/plugin/src/main/java/org/jenkinsci/plugins/activiti_explorer/XmlPatcher.java:
--------------------------------------------------------------------------------
 1 | package org.jenkinsci.plugins.activiti_explorer;
 2 | 
 3 | import org.dom4j.Document;
 4 | import org.dom4j.DocumentException;
 5 | import org.dom4j.Element;
 6 | import org.dom4j.io.OutputFormat;
 7 | import org.dom4j.io.SAXReader;
 8 | import org.dom4j.io.XMLWriter;
 9 | 
10 | import java.io.File;
11 | import java.io.FileOutputStream;
12 | import java.io.IOException;
13 | 
14 | /**
15 |  * @author Kohsuke Kawaguchi
16 |  */
17 | abstract class XmlPatcher {
18 |     private final File xml;
19 |     protected Document dom;
20 | 
21 |     public XmlPatcher(File xml) throws IOException, DocumentException {
22 |         this.xml = xml;
23 |         run();
24 |     }
25 | 
26 |     protected Element findBean(String id) {
27 |         Element bean = (Element)dom.selectSingleNode(String.format("/*/*[@id='%s' or @name='%s']", id,id));
28 |         if (bean==null)
29 |             throw new IllegalStateException("Can't find the "+id+" bean in "+xml);
30 |         return bean;
31 |     }
32 | 
33 |     protected void overrideBeanTo(String id, String className) {
34 |         Element pe = findBean(id);
35 |         pe.elements().clear();
36 |         pe.attributes().clear();
37 |         pe.addAttribute("id", id);
38 |         pe.addAttribute("class", className);
39 |     }
40 | 
41 |     protected void swapClass(String id, String className) {
42 |         Element pe = findBean(id);
43 |         pe.addAttribute("class", className);
44 |     }
45 | 
46 |     protected void removeBean(String id) {
47 |         findBean(id).detach();
48 |     }
49 | 
50 |     public abstract void patch();
51 | 
52 |     public void run() throws DocumentException, IOException {
53 |         dom = new SAXReader().read(xml);
54 | 
55 |         patch();
56 | 
57 |         FileOutputStream out = new FileOutputStream(xml);
58 |         try {
59 |             new XMLWriter(out, OutputFormat.createPrettyPrint()).write(dom);
60 |         } finally {
61 |             out.close();
62 |         }
63 | 
64 |     }
65 | }
66 | 


--------------------------------------------------------------------------------
/pom.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
 3 |   <modelVersion>4.0.0</modelVersion>
 4 | 
 5 |   <parent>
 6 |     <groupId>org.jenkins-ci.plugins</groupId>
 7 |     <artifactId>plugin</artifactId>
 8 |     <version>1.455</version>
 9 |     <relativePath/>
10 |   </parent>
11 | 
12 |   <artifactId>activiti-explorer-plugin-parent</artifactId>
13 |   <version>1.0-SNAPSHOT</version>
14 |   <packaging>pom</packaging>
15 |   <url>https://wiki.jenkins-ci.org/display/JENKINS/Activiti+Explorer+Plugin</url>
16 | 
17 |   <modules>
18 |     <module>plugin</module>
19 |     <module>dto</module>
20 |     <module>activiti-explorer-override</module>
21 |   </modules>
22 | 
23 |   <properties>
24 |     <activiti.version>5.11</activiti.version>
25 |   </properties>
26 |   
27 |   <licenses>
28 |     <license>
29 |       <name>The MIT License (MIT)</name>
30 |       <url>http://www.opensource.org/licenses/mit-license.php</url>
31 |       <distribution>repo</distribution>
32 |     </license>
33 |   </licenses>
34 | 
35 |   <scm>
36 |     <connection>scm:git:ssh://github.com/jenkinsci/activiti-explorer-plugin.git</connection>
37 |     <developerConnection>scm:git:ssh://git@github.com/jenkinsci/activiti-explorer-plugin.git</developerConnection>
38 |     <url>https://github.com/jenkinsci/activiti-explorer-plugin</url>
39 |   </scm>
40 | 
41 |   <repositories>
42 |     <repository>
43 |       <id>repo.jenkins-ci.org</id>
44 |       <url>http://repo.jenkins-ci.org/public/</url>
45 |     </repository>
46 |     <repository>
47 |       <id>repo.activiti</id>
48 |       <url>https://maven.alfresco.com/nexus/content/groups/public/</url>
49 |     </repository>
50 |   </repositories>
51 |   <pluginRepositories>
52 |     <pluginRepository>
53 |       <id>repo.jenkins-ci.org</id>
54 |       <url>http://repo.jenkins-ci.org/public/</url>
55 |     </pluginRepository>
56 |   </pluginRepositories>
57 | 
58 | </project>
59 | 


--------------------------------------------------------------------------------
/activiti-explorer-override/src/main/java/org/jenkinsci/plugins/jenkow/activiti/override/JenkinsLoginHandler.java:
--------------------------------------------------------------------------------
 1 | package org.jenkinsci.plugins.jenkow.activiti.override;
 2 | 
 3 | import org.activiti.explorer.ui.login.LoginHandler;
 4 | import org.activiti.explorer.identity.LoggedInUser;
 5 | import org.jenkinsci.plugins.activiti_explorer.dto.UserDTO;
 6 | 
 7 | import javax.servlet.http.HttpServletRequest;
 8 | import javax.servlet.http.HttpServletResponse;
 9 | import java.util.Map;
10 | 
11 | /**
12 |  * @author Kohsuke Kawaguchi
13 |  */
14 | public class JenkinsLoginHandler implements LoginHandler {
15 |     /**
16 |      * Authenticate the user with the given username and given password.
17 |      *
18 |      * @return the logged in user. Return null of authentication failed.
19 |      */
20 |     public LoggedInUser authenticate(String userName, String password) {
21 |         throw new UnsupportedOperationException();
22 |     }
23 | 
24 |     /**
25 |      * Authenticate the current user. Use this to eg. shared autentication,
26 |      * which can be done without the user actually having to provide
27 |      * credentials.
28 |      *
29 |      * @return The logged in user. Return null, if no user can be logged in
30 |      * automatically. When null is returned, user will be requested to provide
31 |      * credentials.
32 |      */
33 |     public LoggedInUser authenticate(HttpServletRequest request, HttpServletResponse response) {
34 |         return new JenkinsUser((UserDTO)request.getSession().getAttribute("jenkins.user"));
35 |     }
36 | 
37 |     /**
38 |      * Called when the user is logged out, should clear all context related
39 |      * to authorization and authentication for the current logged in user.
40 |      */
41 |     public void logout(LoggedInUser userTologout) {
42 | 
43 |     }
44 | 
45 |     /**
46 |      * Called when request started. Allows eg. validating of authentication or
47 |      * renewing.
48 |      */
49 |     public void onRequestStart(HttpServletRequest request, HttpServletResponse response) {}
50 | 
51 |     /**
52 |      * Called when request started. Allows eg. validating of authentication or
53 |      * renewing.
54 |      */
55 |     public void onRequestEnd(HttpServletRequest request, HttpServletResponse response) {}
56 | 
57 | }
58 | 


--------------------------------------------------------------------------------
/plugin/pom.xml:
--------------------------------------------------------------------------------
  1 | <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  2 |   <modelVersion>4.0.0</modelVersion>
  3 |   <parent>
  4 |     <groupId>org.jenkins-ci.plugins</groupId>
  5 |     <artifactId>activiti-explorer-plugin-parent</artifactId>
  6 |     <version>1.0-SNAPSHOT</version>
  7 |   </parent>
  8 | 
  9 |   <artifactId>activiti-explorer</artifactId>
 10 |   <packaging>hpi</packaging>
 11 | 
 12 |   <dependencies>
 13 |     <dependency>
 14 |       <groupId>${project.groupId}</groupId>
 15 |       <artifactId>activiti-explorer-dto</artifactId>
 16 |       <version>${project.version}</version>
 17 |     </dependency>
 18 |     <dependency>
 19 |       <groupId>com.cisco.step.jenkins.plugins</groupId>
 20 |       <artifactId>jenkow-plugin</artifactId>
 21 |       <version>0.2.6-SNAPSHOT</version>
 22 |     </dependency>
 23 |     <dependency>
 24 |       <groupId>com.cloudbees</groupId>
 25 |       <artifactId>vietnam4j-core</artifactId>
 26 |       <version>1.7</version>
 27 |     </dependency>
 28 |     <dependency>
 29 |       <groupId>${project.groupId}</groupId>
 30 |       <artifactId>activiti-explorer-override</artifactId>
 31 |       <version>1.0-SNAPSHOT</version>
 32 |     </dependency>
 33 |     <dependency>
 34 |       <groupId>org.jenkins-ci.modules</groupId>
 35 |       <artifactId>sshd</artifactId>
 36 |       <version>1.1</version>
 37 |       <scope>provided</scope>
 38 |     </dependency>
 39 |   </dependencies>
 40 | 
 41 |   <build>
 42 |     <plugins>
 43 |       <plugin>
 44 |         <groupId>org.jenkins-ci.tools</groupId>
 45 |         <artifactId>maven-hpi-plugin</artifactId>
 46 |         <version>1.93</version>
 47 |       </plugin>
 48 |       <plugin>
 49 |         <groupId>org.apache.maven.plugins</groupId>
 50 |         <artifactId>maven-dependency-plugin</artifactId>
 51 |         <version>2.5.1</version>
 52 |         <executions>
 53 |           <execution>
 54 |             <id>copy</id>
 55 |             <phase>generate-resources</phase>
 56 |             <goals>
 57 |               <goal>copy</goal>
 58 |             </goals>
 59 |             <configuration>
 60 |               <artifactItems>
 61 |                 <artifactItem>
 62 |                   <groupId>org.activiti</groupId>
 63 |                   <artifactId>activiti-webapp-explorer2</artifactId>
 64 |                   <type>war</type>
 65 |                   <version>${activiti.version}</version>
 66 |                   <outputDirectory>${project.build.directory}/classes</outputDirectory>
 67 |                   <destFileName>activiti-explorer.war</destFileName>
 68 |                 </artifactItem>
 69 |                 <artifactItem>
 70 |                   <groupId>${project.groupId}</groupId>
 71 |                   <artifactId>activiti-explorer-override</artifactId>
 72 |                   <type>jar</type>
 73 |                   <version>${project.version}</version>
 74 |                   <outputDirectory>${project.build.directory}/classes</outputDirectory>
 75 |                   <destFileName>activiti-explorer-override.jar</destFileName>
 76 |                 </artifactItem>
 77 |               </artifactItems>
 78 |             </configuration>
 79 |           </execution>
 80 |         </executions>
 81 |       </plugin>
 82 |     </plugins>
 83 |   </build>
 84 | 
 85 |   <!-- get every artifact through repo.jenkins-ci.org, which proxies all the artifacts that we need -->
 86 |   <repositories>
 87 |     <repository>
 88 |       <id>repo.jenkins-ci.org</id>
 89 |       <url>http://repo.jenkins-ci.org/public/</url>
 90 |     </repository>
 91 |     <repository>
 92 |       <id>repo.activiti</id>
 93 |       <url>https://maven.alfresco.com/nexus/content/groups/public/</url>
 94 |     </repository>
 95 |   </repositories>
 96 | 
 97 |   <pluginRepositories>
 98 |     <pluginRepository>
 99 |       <id>repo.jenkins-ci.org</id>
100 |       <url>http://repo.jenkins-ci.org/public/</url>
101 |     </pluginRepository>
102 |   </pluginRepositories>
103 | </project>
104 | 


--------------------------------------------------------------------------------
/plugin/src/main/java/org/jenkinsci/plugins/activiti_explorer/ActivitiExplorer.java:
--------------------------------------------------------------------------------
  1 | package org.jenkinsci.plugins.activiti_explorer;
  2 | 
  3 | import com.cisco.step.jenkins.plugins.jenkow.JenkowBuilder.DescriptorImpl;
  4 | import com.cisco.step.jenkins.plugins.jenkow.JenkowEngine;
  5 | import com.cloudbees.vietnam4j.ProxiedWebApplication;
  6 | import hudson.Extension;
  7 | import hudson.Util;
  8 | import hudson.model.UnprotectedRootAction;
  9 | import hudson.model.User;
 10 | import jenkins.model.Jenkins;
 11 | import org.acegisecurity.Authentication;
 12 | import org.activiti.engine.ProcessEngine;
 13 | import org.apache.commons.io.IOUtils;
 14 | import org.dom4j.DocumentException;
 15 | import org.jenkinsci.plugins.activiti_explorer.dto.UserDTO;
 16 | import org.jenkinsci.plugins.jenkow.activiti.override.JenkinsProcessEngineFactory;
 17 | import org.jenkinsci.plugins.jenkow.activiti.override.ServletContextDataSource;
 18 | import org.kohsuke.stapler.StaplerRequest;
 19 | import org.kohsuke.stapler.StaplerResponse;
 20 | 
 21 | import javax.inject.Inject;
 22 | import javax.servlet.ServletException;
 23 | import javax.servlet.http.HttpServletRequest;
 24 | import javax.servlet.http.HttpSession;
 25 | import java.io.File;
 26 | import java.io.FileOutputStream;
 27 | import java.io.IOException;
 28 | import java.net.URL;
 29 | import java.net.URLClassLoader;
 30 | import java.util.jar.JarEntry;
 31 | import java.util.jar.JarInputStream;
 32 | 
 33 | /**
 34 |  * Activiti Explorer web application embedded inside Jenkins.
 35 |  *
 36 |  * @author Kohsuke Kawaguchi
 37 |  */
 38 | @Extension
 39 | public class ActivitiExplorer implements UnprotectedRootAction {
 40 |     private ProxiedWebApplication webApp;
 41 | 
 42 |     @Inject
 43 |     DescriptorImpl descriptor;
 44 | 
 45 |     public String getIconFileName() {
 46 |         return "/plugin/activiti-explorer/images/24x24/activiti.png";
 47 |     }
 48 | 
 49 |     public String getDisplayName() {
 50 |         return "Activiti Explorer";
 51 |     }
 52 | 
 53 |     public String getUrlName() {
 54 |         return "activiti-explorer";
 55 |     }
 56 | 
 57 |     public void doDynamic(StaplerRequest req, StaplerResponse rsp) throws ServletException, IOException {
 58 |         ProxiedWebApplication webApp = getProxyWebApplication(req);
 59 | 
 60 |         HttpSession session = req.getSession();
 61 |         HttpSession ps = webApp.getProxiedSession(session);
 62 |         UserDTO oldUser = (UserDTO)ps.getAttribute("jenkins.user");
 63 |         UserDTO newUser = createUserInfo();
 64 |         if (!mapToId(oldUser).equals(mapToId(newUser))) {
 65 |             // force a new session. AE isn't designed to anticipate the user change without invalidating a session,
 66 |             // but Jenkins does that. So when we see that the user has changed in Jenkins, force a new session
 67 |             // (but only in AE.)
 68 |             webApp.clearProxiedSession(session);
 69 |             ps = webApp.getProxiedSession(session);
 70 |         }
 71 | 
 72 |         ps.setAttribute("jenkins.user", newUser);
 73 | 
 74 | 
 75 |         webApp.handleRequest(req, rsp);
 76 |     }
 77 | 
 78 |     private String mapToId(UserDTO o) {
 79 |         return o==null ? "\u0000" : o.id;
 80 |     }
 81 | 
 82 |     /**
 83 |      * Creates {@link UserDTO} that represents the currently logged-in user.
 84 |      */
 85 |     private UserDTO createUserInfo() {
 86 |         Authentication a = Jenkins.getAuthentication();
 87 |         User u = User.current();
 88 | 
 89 |         UserDTO user = new UserDTO();
 90 |         user.id = a.getName();
 91 |         user.firstName = u != null ? u.getFullName() : a.getName();
 92 |         user.lastName = "";
 93 |         user.fullName = u != null ? u.getFullName() : a.getName();
 94 |         user.isAdmin = Jenkins.getInstance().getACL().hasPermission(a,Jenkins.ADMINISTER);
 95 |         user.isUser = true;
 96 | 
 97 |         return user;
 98 |     }
 99 | 
100 |     /**
101 |      * Extracts a war file into the specified directory.
102 |      */
103 |     private void extract(URL war, File dir) throws IOException {
104 |         if (dir.exists())
105 |             Util.deleteRecursive(dir);
106 | 
107 |         JarInputStream jar = new JarInputStream(war.openStream());
108 |         try {
109 |             JarEntry e;
110 |             while ((e=jar.getNextJarEntry())!=null) {
111 |                 File dst = new File(dir,e.getName());
112 |                 if (e.isDirectory())
113 |                     dst.mkdirs();
114 |                 else {
115 |                     dst.getParentFile().mkdirs();
116 |                     FileOutputStream out = new FileOutputStream(dst);
117 |                     try {
118 |                         IOUtils.copy(jar, out);
119 |                     } finally {
120 |                         out.close();
121 |                     }
122 | 
123 |                     if (e.getTime()>=0)
124 |                         dst.setLastModified(e.getTime());
125 |                 }
126 |             }
127 |         } finally {
128 |             jar.close();
129 |         }
130 |     }
131 | 
132 |     /**
133 |      * Patch activiti-explorer war file so that we can inject our stuff into it.
134 |      */
135 |     private void patch(File war) throws DocumentException, IOException {
136 |         new XmlPatcher(new File(war,"WEB-INF/activiti-standalone-context.xml")) {
137 |             public void patch() {
138 |                 // patch data source in
139 |                 overrideBeanTo("dataSource", ServletContextDataSource.class.getName());
140 | 
141 |                 // single sign-on
142 |                 // can't load the class yet, so string
143 |                 overrideBeanTo("activitiLoginHandler", "org.jenkinsci.plugins.jenkow.activiti.override.JenkinsLoginHandler");
144 | 
145 |                 // inject our own fully configured ProcessEngine
146 |                 overrideBeanTo("processEngine", JenkinsProcessEngineFactory.class.getName());
147 | 
148 |                 // no more demo data generation
149 |                 removeBean("demoDataGenerator");
150 |             }
151 |         };
152 |         new XmlPatcher(new File(war,"WEB-INF/activiti-ui-context.xml")) {
153 |             public void patch() {
154 |                 // tweak the navigation bar
155 |                 overrideBeanTo("componentFactories", "org.jenkinsci.plugins.jenkow.activiti.override.JenkinsComponentFactories");
156 | 
157 |                 swapClass("explorerApp","org.jenkinsci.plugins.jenkow.activiti.override.ExplorerApp2");
158 |             }
159 |         };
160 |     }
161 | 
162 |     private synchronized ProxiedWebApplication getProxyWebApplication(StaplerRequest req) throws ServletException {
163 |         if (webApp==null) {
164 |             try {
165 |                 final ClassLoader ourLoader = getClass().getClassLoader();
166 | 
167 |                 File war = new File(Jenkins.getInstance().getRootDir(), "cache/activiti-explorer");
168 |                 extract(ourLoader.getResource("activiti-explorer.war"),war);
169 |                 patch(war);
170 |                 webApp = new ProxiedWebApplication(
171 |                         war,
172 |                         req.getContextPath()+'/'+getUrlName());
173 | 
174 |                 webApp.setParentLoaderHasPriority(true);
175 | 
176 |                 webApp.addClassPath(ourLoader.getResource("activiti-explorer-override.jar"));
177 |                 // inject DataSource
178 |                 webApp.getProxiedServletContext().setAttribute(ServletContextDataSource.class.getName(),
179 |                         descriptor.getDatabase().getDataSource());
180 |                 webApp.getProxiedServletContext().setAttribute(ProcessEngine.class.getName(),
181 |                         JenkowEngine.getEngine());
182 | 
183 |                 // pass through to the servlet container so that Activiti won't get confused
184 |                 // by what Jenkins loads (e.g., log4j version inconsistency)
185 |                 // but we do expose DTO classes to share them between two apps.
186 |                 webApp.setParentClassLoader(new URLClassLoader(new URL[0],HttpServletRequest.class.getClassLoader()) {
187 |                     @Override
188 |                     protected Class<?> findClass(String name) throws ClassNotFoundException {
189 |                         if (name.startsWith("org.jenkinsci.plugins.activiti_explorer.dto.")
190 |                          || name.startsWith("org.activiti.engine.")) {
191 |                             return getClass().getClassLoader().loadClass(name);
192 |                         }
193 |                         throw new ClassNotFoundException(name);
194 |                     }
195 |                 });
196 | 
197 |                 webApp.start();
198 |             } catch (Exception e) {
199 |                 throw new ServletException(e);
200 |             }
201 |         }
202 |         return webApp;
203 |     }
204 | }
205 | 


--------------------------------------------------------------------------------