getCredentials() {
return credentials;
}
@Override
public boolean configure(StaplerRequest req, JSONObject json) throws FormException {
JSONObject hookMode = json.getJSONObject("hookMode");
manageHook = "auto".equals(hookMode.getString("value"));
JSONObject o = hookMode.getJSONObject("hookUrl");
if (o!=null && !o.isNullObject()) {
hookUrl = o.getString("url");
} else {
hookUrl = null;
}
credentials = req.bindJSONToList(Credential.class,hookMode.get("credentials"));
save();
return true;
}
public static DescriptorImpl get() {
return Trigger.all().get(DescriptorImpl.class);
}
public static boolean allowsHookUrlOverride() {
return ALLOW_HOOKURL_OVERRIDE;
}
}
/**
* Set to false to prevent the user from overriding the hook URL.
*/
public static boolean ALLOW_HOOKURL_OVERRIDE = !Boolean.getBoolean(GitHubPushTrigger.class.getName()+".disableOverride");
private static final Logger LOGGER = Logger.getLogger(GitHubPushTrigger.class.getName());
}
github-plugin-github-1.7/src/main/java/com/cloudbees/jenkins/GitHubRepositoryName.java 0000664 0000000 0000000 00000015212 12166346014 0031171 0 ustar 00root root 0000000 0000000 package com.cloudbees.jenkins;
import hudson.util.AdaptedIterator;
import hudson.util.Iterators.FilterIterator;
import org.kohsuke.github.GHCommitPointer;
import org.kohsuke.github.GHRepository;
import org.kohsuke.github.GitHub;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Arrays;
import java.util.Iterator;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* Uniquely identifies a repository on GitHub.
*
* @author Kohsuke Kawaguchi
*/
public class GitHubRepositoryName {
private static final Pattern[] URL_PATTERNS = {
/**
* The first set of patterns extract the host, owner and repository names
* from URLs that include a '.git' suffix, removing the suffix from the
* repository name.
*/
Pattern.compile("git@(.+):([^/]+)/([^/]+)\\.git"),
Pattern.compile("https?://[^/]+@([^/]+)/([^/]+)/([^/]+)\\.git"),
Pattern.compile("https?://([^/]+)/([^/]+)/([^/]+)\\.git"),
Pattern.compile("git://([^/]+)/([^/]+)/([^/]+)\\.git"),
Pattern.compile("ssh://git@([^/]+)/([^/]+)/([^/]+)\\.git"),
/**
* The second set of patterns extract the host, owner and repository names
* from all other URLs. Note that these patterns must be processed *after*
* the first set, to avoid any '.git' suffix that may be present being included
* in the repository name.
*/
Pattern.compile("git@(.+):([^/]+)/([^/]+)/?"),
Pattern.compile("https?://[^/]+@([^/]+)/([^/]+)/([^/]+)/?"),
Pattern.compile("https?://([^/]+)/([^/]+)/([^/]+)/?"),
Pattern.compile("git://([^/]+)/([^/]+)/([^/]+)/?"),
Pattern.compile("ssh://git@([^/]+)/([^/]+)/([^/]+)/?")
};
/**
* Create {@link GitHubRepositoryName} from URL
*
* @param url
* must be non-null
* @return parsed {@link GitHubRepositoryName} or null if it cannot be
* parsed from the specified URL
*/
public static GitHubRepositoryName create(final String url) {
LOGGER.log(Level.FINE, "Constructing from URL {0}", url);
for (Pattern p : URL_PATTERNS) {
Matcher m = p.matcher(url.trim());
if (m.matches()) {
LOGGER.log(Level.FINE, "URL matches {0}", m);
GitHubRepositoryName ret = new GitHubRepositoryName(m.group(1), m.group(2),
m.group(3));
LOGGER.log(Level.FINE, "Object is {0}", ret);
return ret;
}
}
LOGGER.log(Level.WARNING, "Could not match URL {0}", url);
return null;
}
public final String host, userName, repositoryName;
public GitHubRepositoryName(String host, String userName, String repositoryName) {
this.host = host;
this.userName = userName;
this.repositoryName = repositoryName;
}
/**
* Resolves this name to the actual reference by {@link GHRepository}.
*
*
* Since the system can store multiple credentials, and only some of them might be able to see this name in question,
* this method uses {@link GitHubWebHook#login(String, String)} and attempt to find the right credential that can
* access this repository.
*
*
* This method walks multiple repositories for each credential that can access the repository. Depending on
* what you are trying to do with the repository, you might have to keep trying until a {@link GHRepository}
* with suitable permission is returned.
*/
public Iterable resolve() {
return new Iterable() {
public Iterator iterator() {
return filterNull(new AdaptedIterator(GitHubWebHook.get().login(host,userName)) {
protected GHRepository adapt(GitHub item) {
try {
GHRepository repo = item.getUser(userName).getRepository(repositoryName);
if (repo == null) {
repo = item.getOrganization(userName).getRepository(repositoryName);
}
return repo;
} catch (IOException e) {
LOGGER.log(Level.WARNING,"Failed to obtain repository "+this,e);
return null;
}
}
});
}
};
}
/**
* Variation of {@link #resolve()} method that just returns the first valid repository object.
*
* This is useful if the caller only relies on the read access to the repository and doesn't need to
* walk possible candidates.
*/
public GHRepository resolveOne() {
for (GHRepository r : resolve())
return r;
return null;
}
private Iterator filterNull(Iterator itr) {
return new FilterIterator(itr) {
@Override
protected boolean filter(V v) {
return v!=null;
}
};
}
/**
* Does this repository match the repository referenced in the given {@link GHCommitPointer}?
*/
public boolean matches(GHCommitPointer commit) {
try {
return userName.equals(commit.getUser().getLogin())
&& repositoryName.equals(commit.getRepository().getName())
&& host.equals(new URL(commit.getRepository().getUrl()).getHost());
} catch (MalformedURLException e) {
return false;
}
}
/**
* Does this repository match the repository referenced in the given {@link GHCommitPointer}?
*/
public boolean matches(GHRepository repo) throws IOException {
return userName.equals(repo.getOwner().getLogin()) // TODO: use getOwnerName
&& repositoryName.equals(repo.getName())
&& host.equals(new URL(repo.getUrl()).getHost());
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
GitHubRepositoryName that = (GitHubRepositoryName) o;
return repositoryName.equals(that.repositoryName) && userName.equals(that.userName) && host.equals(that.host);
}
@Override
public int hashCode() {
return Arrays.hashCode(new Object[] {host, userName, repositoryName});
}
@Override
public String toString() {
return "GitHubRepository[host="+host+",username="+userName+",repository="+repositoryName+"]";
}
private static final Logger LOGGER = Logger.getLogger(GitHubRepositoryName.class.getName());
}
github-plugin-github-1.7/src/main/java/com/cloudbees/jenkins/GitHubRepositoryNameContributor.java 0000664 0000000 0000000 00000005407 12166346014 0033431 0 ustar 00root root 0000000 0000000 package com.cloudbees.jenkins;
import hudson.Extension;
import hudson.ExtensionList;
import hudson.ExtensionPoint;
import hudson.model.AbstractProject;
import hudson.plugins.git.GitSCM;
import hudson.scm.SCM;
import jenkins.model.Jenkins;
import org.eclipse.jgit.transport.RemoteConfig;
import org.eclipse.jgit.transport.URIish;
import org.jenkinsci.plugins.multiplescms.MultiSCM;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
/**
* Extension point that associates {@link GitHubRepositoryName}s to a project.
*
* @author Kohsuke Kawaguchi
* @since 1.7
*/
public abstract class GitHubRepositoryNameContributor implements ExtensionPoint {
/**
* Looks at the definition of {@link AbstractProject} and list up the related github repositories,
* then puts them into the collection.
*/
public abstract void parseAssociatedNames(AbstractProject job, Collection result);
public static ExtensionList all() {
return Jenkins.getInstance().getExtensionList(GitHubRepositoryNameContributor.class);
}
public static Collection parseAssociatedNames(AbstractProject job) {
Set names = new HashSet();
for (GitHubRepositoryNameContributor c : all())
c.parseAssociatedNames(job,names);
return names;
}
/**
* Default implementation that looks at SCM
*/
@Extension
public static class FromSCM extends GitHubRepositoryNameContributor {
@Override
public void parseAssociatedNames(AbstractProject job, Collection result) {
if (Jenkins.getInstance().getPlugin("multiple-scms") != null
&& job.getScm() instanceof MultiSCM) {
MultiSCM multiSCM = (MultiSCM) job.getScm();
List scmList = multiSCM.getConfiguredSCMs();
for (SCM scm : scmList) {
addRepositories(scm, result);
}
} else {
addRepositories(job.getScm(), result);
}
}
private void addRepositories(SCM scm, Collection r) {
if (scm instanceof GitSCM) {
GitSCM git = (GitSCM) scm;
for (RemoteConfig rc : git.getRepositories()) {
for (URIish uri : rc.getURIs()) {
String url = uri.toString();
GitHubRepositoryName repo = GitHubRepositoryName.create(url);
if (repo != null) {
r.add(repo);
}
}
}
}
}
}
}
github-plugin-github-1.7/src/main/java/com/cloudbees/jenkins/GitHubTrigger.java 0000664 0000000 0000000 00000003566 12166346014 0027625 0 ustar 00root root 0000000 0000000 package com.cloudbees.jenkins;
import hudson.Extension;
import hudson.Util;
import hudson.model.AbstractProject;
import hudson.triggers.Trigger;
import java.util.Collection;
import java.util.Set;
/**
* Optional interface that can be implemented by {@link Trigger} that watches out for a change in GitHub
* and triggers a build.
*
* @author aaronwalker
*/
public interface GitHubTrigger {
@Deprecated
public void onPost();
// TODO: document me
public void onPost(String triggeredByUser);
/**
* Obtains the list of the repositories that this trigger is looking at.
*
* If the implementation of this class maintain its own list of GitHub repositories, it should
* continue to implement this method for backward compatibility, and it gets picked up by
* {@link GitHubRepositoryNameContributor#parseAssociatedNames(AbstractProject)}.
*
*
* Alternatively, if the implementation doesn't worry about the backward compatibility, it can
* implement this method to return an empty collection, then just implement {@link GitHubRepositoryNameContributor}.
*
* @deprecated
* Call {@link GitHubRepositoryNameContributor#parseAssociatedNames(AbstractProject)} instead.
*/
public Set getGitHubRepositories();
/**
* Contributes {@link GitHubRepositoryName} from {@link GitHubTrigger#getGitHubRepositories()}
* for backward compatibility
*/
@Extension
public static class GitHubRepositoryNameContributorImpl extends GitHubRepositoryNameContributor {
@Override
public void parseAssociatedNames(AbstractProject job, Collection result) {
for (GitHubTrigger ght : Util.filter(job.getTriggers().values(),GitHubTrigger.class)) {
result.addAll(ght.getGitHubRepositories());
}
}
}
}
github-plugin-github-1.7/src/main/java/com/cloudbees/jenkins/GitHubWebHook.java 0000664 0000000 0000000 00000017234 12166346014 0027555 0 ustar 00root root 0000000 0000000 package com.cloudbees.jenkins;
import com.cloudbees.jenkins.GitHubPushTrigger.DescriptorImpl;
import hudson.Extension;
import hudson.model.AbstractProject;
import hudson.model.Hudson;
import hudson.model.RootAction;
import hudson.model.UnprotectedRootAction;
import hudson.security.ACL;
import hudson.triggers.Trigger;
import hudson.util.AdaptedIterator;
import hudson.util.Iterators.FilterIterator;
import net.sf.json.JSONObject;
import org.acegisecurity.Authentication;
import org.acegisecurity.context.SecurityContextHolder;
import org.kohsuke.github.GitHub;
import org.kohsuke.stapler.StaplerRequest;
import java.io.IOException;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.logging.Logger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import static java.util.logging.Level.*;
/**
* Receives github hook.
*
* @author Kohsuke Kawaguchi
*/
@Extension
public class GitHubWebHook implements UnprotectedRootAction {
private static final Pattern REPOSITORY_NAME_PATTERN = Pattern.compile("https?://([^/]+)/([^/]+)/([^/]+)");
public String getIconFileName() {
return null;
}
public String getDisplayName() {
return null;
}
public String getUrlName() {
return "github-webhook";
}
/**
* Logs in as the given user and returns the connection object.
*/
public Iterable login(String host, String userName) {
if (host.equals("github.com")) {
final List l = DescriptorImpl.get().getCredentials();
// if the username is not an organization, we should have the right user account on file
for (Credential c : l) {
if (c.username.equals(userName))
try {
return Collections.singleton(c.login());
} catch (IOException e) {
LOGGER.log(WARNING,"Failed to login with username="+c.username,e);
return Collections.emptyList();
}
}
// otherwise try all the credentials since we don't know which one would work
return new Iterable() {
public Iterator iterator() {
return new FilterIterator(
new AdaptedIterator(l) {
protected GitHub adapt(Credential c) {
try {
return c.login();
} catch (IOException e) {
LOGGER.log(WARNING,"Failed to login with username="+c.username,e);
return null;
}
}
}) {
protected boolean filter(GitHub g) {
return g!=null;
}
};
}
};
} else {
return Collections. emptyList();
}
}
/*
{
"after":"ea50ac0026d6d9c284e04afba1cc95d86dc3d976",
"before":"501f46e557f8fc5e0fa4c88a7f4597ef597dd1bf",
"commits":[
{
"added":["b"],
"author":{"email":"kk@kohsuke.org","name":"Kohsuke Kawaguchi","username":"kohsuke"},
"id":"3c696af1225e63ed531f5656e8f9cc252e4c96a2",
"message":"another commit",
"modified":[],
"removed":[],
"timestamp":"2010-12-08T14:31:24-08:00",
"url":"https://github.com/kohsuke/foo/commit/3c696af1225e63ed531f5656e8f9cc252e4c96a2"
},{
"added":["d"],
"author":{"email":"kk@kohsuke.org","name":"Kohsuke Kawaguchi","username":"kohsuke"},
"id":"ea50ac0026d6d9c284e04afba1cc95d86dc3d976",
"message":"new commit",
"modified":[],
"removed":[],
"timestamp":"2010-12-08T14:32:11-08:00",
"url":"https://github.com/kohsuke/foo/commit/ea50ac0026d6d9c284e04afba1cc95d86dc3d976"
}
],
"compare":"https://github.com/kohsuke/foo/compare/501f46e...ea50ac0",
"forced":false,
"pusher":{"email":"kk@kohsuke.org","name":"kohsuke"},
"ref":"refs/heads/master",
"repository":{
"created_at":"2010/12/08 12:44:13 -0800",
"description":"testing",
"fork":false,
"forks":1,
"has_downloads":true,
"has_issues":true,
"has_wiki":true,
"homepage":"testing",
"name":"foo",
"open_issues":0,
"owner":{"email":"kk@kohsuke.org","name":"kohsuke"},
"private":false,
"pushed_at":"2010/12/08 14:32:23 -0800",
"url":"https://github.com/kohsuke/foo","watchers":1
}
}
*/
/**
* 1 push to 2 branches will result in 2 pushes.
*/
// XXX probably want (when available in baseline Stapler version): @RequirePOST
public void doIndex(StaplerRequest req) {
String payload = req.getParameter("payload");
if (payload == null) {
throw new IllegalArgumentException("Not intended to be browsed interactively (must specify payload parameter)");
}
processGitHubPayload(payload,GitHubPushTrigger.class);
}
public void processGitHubPayload(String payload, Class> triggerClass) {
JSONObject o = JSONObject.fromObject(payload);
String repoUrl = o.getJSONObject("repository").getString("url"); // something like 'https://github.com/kohsuke/foo'
String pusherName = o.getJSONObject("pusher").getString("name");
LOGGER.info("Received POST for "+repoUrl);
LOGGER.fine("Full details of the POST was "+o.toString());
Matcher matcher = REPOSITORY_NAME_PATTERN.matcher(repoUrl);
if (matcher.matches()) {
// run in high privilege to see all the projects anonymous users don't see.
// this is safe because when we actually schedule a build, it's a build that can
// happen at some random time anyway.
Authentication old = SecurityContextHolder.getContext().getAuthentication();
SecurityContextHolder.getContext().setAuthentication(ACL.SYSTEM);
try {
GitHubRepositoryName changedRepository = GitHubRepositoryName.create(repoUrl);
for (AbstractProject job : Hudson.getInstance().getAllItems(AbstractProject.class)) {
GitHubTrigger trigger = (GitHubTrigger) job.getTrigger(triggerClass);
if (trigger!=null) {
LOGGER.fine("Considering to poke "+job.getFullDisplayName());
if (GitHubRepositoryNameContributor.parseAssociatedNames(job).contains(changedRepository)) {
LOGGER.info("Poked "+job.getFullDisplayName());
trigger.onPost(pusherName);
} else
LOGGER.fine("Skipped "+job.getFullDisplayName()+" because it doesn't have a matching repository.");
}
}
} finally {
SecurityContextHolder.getContext().setAuthentication(old);
}
} else {
LOGGER.warning("Malformed repo url "+repoUrl);
}
}
private static final Logger LOGGER = Logger.getLogger(GitHubWebHook.class.getName());
public static GitHubWebHook get() {
return Hudson.getInstance().getExtensionList(RootAction.class).get(GitHubWebHook.class);
}
}
github-plugin-github-1.7/src/main/java/com/coravy/ 0000775 0000000 0000000 00000000000 12166346014 0022137 5 ustar 00root root 0000000 0000000 github-plugin-github-1.7/src/main/java/com/coravy/hudson/ 0000775 0000000 0000000 00000000000 12166346014 0023437 5 ustar 00root root 0000000 0000000 github-plugin-github-1.7/src/main/java/com/coravy/hudson/plugins/ 0000775 0000000 0000000 00000000000 12166346014 0025120 5 ustar 00root root 0000000 0000000 github-plugin-github-1.7/src/main/java/com/coravy/hudson/plugins/github/ 0000775 0000000 0000000 00000000000 12166346014 0026402 5 ustar 00root root 0000000 0000000 github-plugin-github-1.7/src/main/java/com/coravy/hudson/plugins/github/GithubLinkAction.java 0000664 0000000 0000000 00000001660 12166346014 0032446 0 ustar 00root root 0000000 0000000 package com.coravy.hudson.plugins.github;
import hudson.model.Action;
/**
* Add the Github Logo/Icon to the sidebar.
*
* @author Stefan Saasen
*/
public final class GithubLinkAction implements Action {
private final transient GithubProjectProperty projectProperty;
public GithubLinkAction(GithubProjectProperty githubProjectProperty) {
this.projectProperty = githubProjectProperty;
}
/*
* (non-Javadoc)
* @see hudson.model.Action#getDisplayName()
*/
public String getDisplayName() {
return "GitHub";
}
/*
* (non-Javadoc)
* @see hudson.model.Action#getIconFileName()
*/
public String getIconFileName() {
return "/plugin/github/logov3.png";
}
/*
* (non-Javadoc)
* @see hudson.model.Action#getUrlName()
*/
public String getUrlName() {
return projectProperty.getProjectUrl().baseUrl();
}
}
github-plugin-github-1.7/src/main/java/com/coravy/hudson/plugins/github/GithubLinkAnnotator.java 0000664 0000000 0000000 00000005063 12166346014 0033177 0 ustar 00root root 0000000 0000000 package com.coravy.hudson.plugins.github;
import hudson.Extension;
import hudson.MarkupText;
import hudson.MarkupText.SubText;
import hudson.model.AbstractBuild;
import hudson.plugins.git.GitChangeSet;
import hudson.scm.ChangeLogAnnotator;
import hudson.scm.ChangeLogSet.Entry;
import java.util.regex.Pattern;
/**
* This class annotates changelog links.
*
* It's based on the TracLinkAnnotator.
*
*
* @todo Change the annotator to use GithubUrl instead of the String url.
* Knowledge about the github url structure should be encapsulated in
* GithubUrl.
* @author Stefan Saasen
*/
@Extension
public class GithubLinkAnnotator extends ChangeLogAnnotator {
@Override
public void annotate(AbstractBuild build, Entry change,
MarkupText text) {
final GithubProjectProperty p = build.getProject().getProperty(
GithubProjectProperty.class);
if (null == p || null == p.getProjectUrl()) {
return;
}
annotate(p.getProjectUrl(), text, change);
}
void annotate(final GithubUrl url, final MarkupText text, final Entry change) {
final String base = url.baseUrl();
for (LinkMarkup markup : MARKUPS) {
markup.process(text, base);
}
if(change instanceof GitChangeSet) {
GitChangeSet cs = (GitChangeSet)change;
text.wrapBy("", " (commit: "+cs.getId()+")");
}
}
private static final class LinkMarkup {
private final Pattern pattern;
private final String href;
LinkMarkup(String pattern, String href) {
// \\\\d becomes \\d when in the expanded text.
pattern = NUM_PATTERN.matcher(pattern).replaceAll("(\\\\d+)");
pattern = ANYWORD_PATTERN.matcher(pattern).replaceAll(
"((?:\\\\w|[._-])+)");
this.pattern = Pattern.compile(pattern);
this.href = href;
}
void process(MarkupText text, String url) {
for (SubText st : text.findTokens(pattern)) {
st.surroundWith("", "");
}
}
private static final Pattern NUM_PATTERN = Pattern.compile("NUM");
private static final Pattern ANYWORD_PATTERN = Pattern
.compile("ANYWORD");
}
private static final LinkMarkup[] MARKUPS = new LinkMarkup[] { new LinkMarkup(
"(?:C|c)lose(?:s?)\\s(?
* As of now this is only the URL to the github project.
*
* @todo Should we store the GithubUrl instead of the String?
* @author Stefan Saasen
*/
public final class GithubProjectProperty extends
JobProperty> {
/**
* This will the URL to the project main branch.
*/
private String projectUrl;
@DataBoundConstructor
public GithubProjectProperty(String projectUrl) {
this.projectUrl = new GithubUrl(projectUrl).baseUrl();
}
/**
* @return the projectUrl
*/
public GithubUrl getProjectUrl() {
return new GithubUrl(projectUrl);
}
@Override
public Collection getJobActions(AbstractProject job) {
if (null != projectUrl) {
return Collections.singleton(new GithubLinkAction(this));
}
return Collections.emptyList();
}
/*
@Override
public JobPropertyDescriptor getDescriptor() {
return DESCRIPTOR;
}
public static final DescriptorImpl DESCRIPTOR = new DescriptorImpl();
*/
@Extension
public static final class DescriptorImpl extends JobPropertyDescriptor {
public DescriptorImpl() {
super(GithubProjectProperty.class);
load();
}
public boolean isApplicable(Class jobType) {
return AbstractProject.class.isAssignableFrom(jobType);
}
public String getDisplayName() {
return "GitHub project page";
}
@Override
public JobProperty newInstance(StaplerRequest req,
JSONObject formData) throws FormException {
GithubProjectProperty tpp = req.bindJSON(
GithubProjectProperty.class, formData);
if (tpp.projectUrl == null) {
tpp = null; // not configured
}
return tpp;
}
}
}
github-plugin-github-1.7/src/main/java/com/coravy/hudson/plugins/github/GithubUrl.java 0000664 0000000 0000000 00000002726 12166346014 0031161 0 ustar 00root root 0000000 0000000 package com.coravy.hudson.plugins.github;
import org.apache.commons.lang.StringUtils;
/**
*
* @author Stefan Saasen
*/
public final class GithubUrl {
/**
* Normalizes the github URL.
*
* Removes unwanted path elements (e.g. tree/master).
*
* @return URL to the project or null if input is invalid.
*/
private static String normalize(String url) {
if (StringUtils.isBlank(url)) {
return null;
}
// Strip "/tree/..."
if (url.contains("/tree/")) {
url = url.replaceFirst("/tree/.*$", "");
}
if (!url.endsWith("/")) {
url += '/';
}
return url;
}
private final String baseUrl;
GithubUrl(final String input) {
this.baseUrl = normalize(input);
}
/*
* (non-Javadoc)
* @see java.lang.Object#toString()
*/
@Override
public String toString() {
return this.baseUrl;
}
/**
*
* @return
*/
public String baseUrl() {
return this.baseUrl;
}
/**
* Returns the URL to a particular commit.
*
* @param id - the git SHA1 hash
* @return URL String (e.g. http://github.com/juretta/hudson-github-plugin/commit/5e31203faea681c41577b685818a361089fac1fc)
*/
public String commitId(final String id) {
return new StringBuilder().append(baseUrl).append("commit/").append(id).toString();
}
}
github-plugin-github-1.7/src/main/resources/ 0000775 0000000 0000000 00000000000 12166346014 0021147 5 ustar 00root root 0000000 0000000 github-plugin-github-1.7/src/main/resources/com/ 0000775 0000000 0000000 00000000000 12166346014 0021725 5 ustar 00root root 0000000 0000000 github-plugin-github-1.7/src/main/resources/com/cloudbees/ 0000775 0000000 0000000 00000000000 12166346014 0023672 5 ustar 00root root 0000000 0000000 github-plugin-github-1.7/src/main/resources/com/cloudbees/jenkins/ 0000775 0000000 0000000 00000000000 12166346014 0025333 5 ustar 00root root 0000000 0000000 github-plugin-github-1.7/src/main/resources/com/cloudbees/jenkins/Credential/ 0000775 0000000 0000000 00000000000 12166346014 0027405 5 ustar 00root root 0000000 0000000 github-plugin-github-1.7/src/main/resources/com/cloudbees/jenkins/Credential/config.jelly 0000664 0000000 0000000 00000001130 12166346014 0031706 0 ustar 00root root 0000000 0000000
github-plugin-github-1.7/src/main/resources/com/cloudbees/jenkins/Credential/help-apiUrl.html 0000664 0000000 0000000 00000000317 12166346014 0032456 0 ustar 00root root 0000000 0000000
If you use GitHub Enterprise you may specify the API end point here
(e.g., "https://ghe.acme.com/api/v3"). An OAuth token is required and
the password is ignored if you specify one.
github-plugin-github-1.7/src/main/resources/com/cloudbees/jenkins/Credential/help-password.html 0000664 0000000 0000000 00000000117 12166346014 0033062 0 ustar 00root root 0000000 0000000
Password is no longer required if you specify an OAuth token.
github-plugin-github-1.7/src/main/resources/com/cloudbees/jenkins/Credential/help-username.html 0000664 0000000 0000000 00000000214 12166346014 0033035 0 ustar 00root root 0000000 0000000
If your Jenkins uses multiple repositories that are spread across different
user accounts, you can list them all here.
github-plugin-github-1.7/src/main/resources/com/cloudbees/jenkins/GitHubPushTrigger/ 0000775 0000000 0000000 00000000000 12166346014 0030701 5 ustar 00root root 0000000 0000000 GitHubWebHookPollingAction/ 0000775 0000000 0000000 00000000000 12166346014 0035746 5 ustar 00root root 0000000 0000000 github-plugin-github-1.7/src/main/resources/com/cloudbees/jenkins/GitHubPushTrigger index.jelly 0000664 0000000 0000000 00000003400 12166346014 0040113 0 ustar 00root root 0000000 0000000 github-plugin-github-1.7/src/main/resources/com/cloudbees/jenkins/GitHubPushTrigger/GitHubWebHookPollingAction
${%Last GitHub Push}
${%Polling has not run yet.}
${it.writeLogTo(output)}
github-plugin-github-1.7/src/main/resources/com/cloudbees/jenkins/GitHubPushTrigger/global.jelly 0000664 0000000 0000000 00000003241 12166346014 0033202 0 ustar 00root root 0000000 0000000
github-plugin-github-1.7/src/main/resources/com/cloudbees/jenkins/GitHubPushTrigger/help-auto.jelly 0000664 0000000 0000000 00000001576 12166346014 0033651 0 ustar 00root root 0000000 0000000
In this mode, Jenkins will add/remove hook URLs to GitHub based on the project configuration of Jenkins.
Jenkins has a single post-commit hook URL for all the repositories, and this URL will be added to
all the GitHub repositories Jenkins is interested in.
This URL is ${app.rootUrl}github-webhook/,
and it needs to be accessible from the internet. If you have a firewall and such between GitHub
and Jenkins, you can set up a reverse proxy and override the hook URL that Jenkins registers to GitHub,
by checking "override hook URL" and specify the URL GitHub should POST to.
If your Jenkins runs inside the firewall and not directly reachable from the internet,
set up a reverse proxy, port tunneling, and so on so that GitHub can deliver a POST request
to your Jenkins at
${app.rootUrl}github-webhook/.
Then specify the URL that GitHub should POST to here.
Don't let Jenkins talk to GitHub and manage post commit hook URLs, and opt to do it manually.
In this mode, in addition to configure projects with "Build when a change is pushed to GitHub",
you need to ensure that Jenkins gets a POST to its
${app.rootUrl}github-webhook/
This plugin integrates
GitHub to Jenkins.
Enter the URL for the GitHub hosted project (without the tree/master or tree/branch part).
For example:
http://github.com/rails/rails for the Rails project.
github-plugin-github-1.7/src/main/webapp/help-global_de.html 0000664 0000000 0000000 00000000373 12166346014 0024142 0 ustar 00root root 0000000 0000000
URL des GitHub-Projektes (ohne den Pfad der den Zweig des Repositories angibt - also ohne tree/master oder tree/branch).
Zum Beispiel http://github.com/rails/rails für das Rails-Projekt.
github-plugin-github-1.7/src/main/webapp/logov3.png 0000664 0000000 0000000 00000003020 12166346014 0022325 0 ustar 00root root 0000000 0000000 PNG
IHDR w= tEXtSoftware Adobe ImageReadyqe< "iTXtXML:com.adobe.xmp =r IDATxڬkKQr۲0$B
͂",^4[bҋ^FDve +X]
w[ qfΜrs+/DX+V4bD<OxSJb91,y_*VeE.[[ C-b'Ex-NzIǨߒp]qFlY#Z9Q7 gdBqHe` G FĸW̭Ҧ 37=%YEKh1oRM;) c,AMnf}eP s$glFe(
^|Y<ۆ)9ô$ zAi$9xX L?i
bA }ꖱB|)ivA@y..`I%R0*PF ^p$7G,j
\c)}>a#5
!u'4j$ҟ`#S v)+am|7V@Fv j7(?H? JwP> &,EY( . vm@q
I credentials = d.getCredentials();
assertNotNull(credentials);
assertEquals(1, credentials.size());
Credential credential = credentials.get(0);
assertEquals("jenkins", credential.username);
assertEquals("password", Secret.toString(credential.password));
}
public void testConfigSubmit_ManuallyManageHook() throws Exception {
WebClient client = configureWebClient();
HtmlPage p = client.goTo("configure");
HtmlForm f = p.getFormByName("config");
f.getInputByValue("none").setChecked(true);
submit(f);
GitHubPushTrigger.DescriptorImpl d = getDescriptor();
assertFalse(d.isManageHook());
}
private GitHubPushTrigger.DescriptorImpl getDescriptor() {
return (GitHubPushTrigger.DescriptorImpl) GitHubPushTrigger.DescriptorImpl.get();
}
private WebClient configureWebClient() {
WebClient client = new WebClient();
client.setThrowExceptionOnFailingStatusCode(false);
client.setCssEnabled(false);
client.setJavaScriptEnabled(true);
return client;
}
// workaround
static {
Stapler.CONVERT_UTILS.register(new org.apache.commons.beanutils.Converter() {
public Secret convert(Class type, Object value) {
return Secret.fromString(value.toString());
}
}, Secret.class);
}
}
github-plugin-github-1.7/src/test/java/com/coravy/ 0000775 0000000 0000000 00000000000 12166346014 0022172 5 ustar 00root root 0000000 0000000 github-plugin-github-1.7/src/test/java/com/coravy/hudson/ 0000775 0000000 0000000 00000000000 12166346014 0023472 5 ustar 00root root 0000000 0000000 github-plugin-github-1.7/src/test/java/com/coravy/hudson/plugins/ 0000775 0000000 0000000 00000000000 12166346014 0025153 5 ustar 00root root 0000000 0000000 github-plugin-github-1.7/src/test/java/com/coravy/hudson/plugins/github/ 0000775 0000000 0000000 00000000000 12166346014 0026435 5 ustar 00root root 0000000 0000000 GitHubRepositoryNameTest.java 0000664 0000000 0000000 00000014201 12166346014 0034142 0 ustar 00root root 0000000 0000000 github-plugin-github-1.7/src/test/java/com/coravy/hudson/plugins/github package com.coravy.hudson.plugins.github;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import com.cloudbees.jenkins.GitHubRepositoryName;
import org.junit.Test;
/**
* Unit tests of {@link GitHubRepositoryName}
*/
public class GitHubRepositoryNameTest {
private void testURL(String URL, String host, String owner, String repository)
{
GitHubRepositoryName repo = GitHubRepositoryName.create(URL);
assertNotNull(repo);
assertEquals(host, repo.host);
assertEquals(owner, repo.userName);
assertEquals(repository, repo.repositoryName);
}
@Test
public void gitAtUrlGitHub() {
testURL("git@github.com:jenkinsci/jenkins.git", "github.com", "jenkinsci", "jenkins");
}
@Test
public void gitAtUrlOtherHost() {
testURL("git@gh.company.com:jenkinsci/jenkins.git", "gh.company.com", "jenkinsci", "jenkins");
}
@Test
public void gitColonUrlGitHub() {
testURL("git://github.com/jenkinsci/jenkins.git", "github.com", "jenkinsci", "jenkins");
}
@Test
public void gitColonUrlOtherHost() {
testURL("git://company.net/jenkinsci/jenkins.git", "company.net", "jenkinsci", "jenkins");
}
@Test
public void httpsUrlGitHub() {
testURL("https://user@github.com/jenkinsci/jenkins.git", "github.com", "jenkinsci", "jenkins");
}
@Test
public void httpsUrlGitHubWithoutUser() {
testURL("https://github.com/jenkinsci/jenkins.git", "github.com", "jenkinsci", "jenkins");
}
@Test
public void httpsUrlOtherHost() {
testURL("https://employee@gh.company.com/jenkinsci/jenkins.git", "gh.company.com", "jenkinsci", "jenkins");
}
@Test
public void gitAtUrlGitHubNoSuffix() {
testURL("git@github.com:jenkinsci/jenkins", "github.com", "jenkinsci", "jenkins");
}
@Test
public void gitAtUrlOtherHostNoSuffix() {
testURL("git@gh.company.com:jenkinsci/jenkins", "gh.company.com", "jenkinsci", "jenkins");
}
@Test
public void gitColonUrlGitHubNoSuffix() {
testURL("git://github.com/jenkinsci/jenkins", "github.com", "jenkinsci", "jenkins");
}
@Test
public void gitColonUrlOtherHostNoSuffix() {
testURL("git://company.net/jenkinsci/jenkins", "company.net", "jenkinsci", "jenkins");
}
@Test
public void httpsUrlGitHubNoSuffix() {
testURL("https://user@github.com/jenkinsci/jenkins", "github.com", "jenkinsci", "jenkins");
}
@Test
public void httpsUrlGitHubWithoutUserNoSuffix() {
testURL("https://github.com/jenkinsci/jenkins", "github.com", "jenkinsci", "jenkins");
}
@Test
public void httpsUrlOtherHostNoSuffix() {
testURL("https://employee@gh.company.com/jenkinsci/jenkins", "gh.company.com", "jenkinsci", "jenkins");
}
@Test
public void gitAtUrlGitHubTrailingSlash() {
GitHubRepositoryName repo = GitHubRepositoryName
.create("git@github.com:jenkinsci/jenkins/");
assertNotNull(repo);
assertEquals("jenkinsci", repo.userName);
assertEquals("jenkins", repo.repositoryName);
assertEquals("github.com", repo.host);
}
@Test
public void gitAtUrlOtherHostTrailingSlash() {
GitHubRepositoryName repo = GitHubRepositoryName
.create("git@gh.company.com:jenkinsci/jenkins/");
assertNotNull(repo);
assertEquals("jenkinsci", repo.userName);
assertEquals("jenkins", repo.repositoryName);
assertEquals("gh.company.com", repo.host);
}
@Test
public void gitColonUrlGitHubTrailingSlash() {
GitHubRepositoryName repo = GitHubRepositoryName
.create("git://github.com/jenkinsci/jenkins/");
assertNotNull(repo);
assertEquals("jenkinsci", repo.userName);
assertEquals("jenkins", repo.repositoryName);
assertEquals("github.com", repo.host);
}
@Test
public void gitColonUrlOtherHostTrailingSlash() {
GitHubRepositoryName repo = GitHubRepositoryName
.create("git://company.net/jenkinsci/jenkins/");
assertNotNull(repo);
assertEquals("jenkinsci", repo.userName);
assertEquals("jenkins", repo.repositoryName);
assertEquals("company.net", repo.host);
}
@Test
public void httpsUrlGitHubTrailingSlash() {
GitHubRepositoryName repo = GitHubRepositoryName
.create("https://user@github.com/jenkinsci/jenkins/");
assertNotNull(repo);
assertEquals("jenkinsci", repo.userName);
assertEquals("jenkins", repo.repositoryName);
assertEquals("github.com", repo.host);
}
@Test
public void httpsUrlGitHubWithoutUserTrailingSlash() {
//this is valid for anonymous usage
GitHubRepositoryName repo = GitHubRepositoryName
.create("https://github.com/jenkinsci/jenkins/");
assertNotNull(repo);
assertEquals("jenkinsci", repo.userName);
assertEquals("jenkins", repo.repositoryName);
assertEquals("github.com", repo.host);
}
@Test
public void httpsUrlOtherHostTrailingSlash() {
GitHubRepositoryName repo = GitHubRepositoryName
.create("https://employee@gh.company.com/jenkinsci/jenkins/");
assertNotNull(repo);
assertEquals("jenkinsci", repo.userName);
assertEquals("jenkins", repo.repositoryName);
assertEquals("gh.company.com", repo.host);
}
@Test
public void trimWhitespace() {
GitHubRepositoryName repo = GitHubRepositoryName
.create(" https://user@github.com/jenkinsci/jenkins/ ");
assertNotNull(repo);
assertEquals("jenkinsci", repo.userName);
assertEquals("jenkins", repo.repositoryName);
assertEquals("github.com", repo.host);
}
@Test
public void badProtocol() {
GitHubRepositoryName repo = GitHubRepositoryName
.create("gopher://gopher.floodgap.com");
assertNull(repo);
}
@Test
public void missingColon() {
GitHubRepositoryName repo = GitHubRepositoryName
.create("https//github.com/jenkinsci/jenkins");
assertNull(repo);
}
}
github-plugin-github-1.7/src/test/java/com/coravy/hudson/plugins/github/GithubLinkAnnotatorTest.java0000664 0000000 0000000 00000002663 12166346014 0034075 0 ustar 00root root 0000000 0000000 package com.coravy.hudson.plugins.github;
import static org.junit.Assert.assertEquals;
import hudson.MarkupText;
import org.junit.Test;
public class GithubLinkAnnotatorTest {
private final static String GITHUB_URL = "http://github.com/juretta/iphone-project-tools/";
@Test
public final void testAnnotateStringMarkupText() {
assertAnnotatedTextEquals("An issue Closes #1 link",
"An issue Closes #1 link");
assertAnnotatedTextEquals("An issue Close #1 link",
"An issue Close #1 link");
assertAnnotatedTextEquals("An issue closes #123 link",
"An issue closes #123 link");
assertAnnotatedTextEquals("An issue close #9876 link",
"An issue close #9876 link");
}
private void assertAnnotatedTextEquals(final String originalText,
final String expectedAnnotatedText) {
MarkupText markupText = new MarkupText(originalText);
GithubLinkAnnotator annotator = new GithubLinkAnnotator();
annotator.annotate(new GithubUrl(GITHUB_URL), markupText, null);
assertEquals(expectedAnnotatedText, markupText.toString());
}
}
github-plugin-github-1.7/src/test/java/com/coravy/hudson/plugins/github/GithubUrlTest.java 0000664 0000000 0000000 00000002664 12166346014 0032055 0 ustar 00root root 0000000 0000000 package com.coravy.hudson.plugins.github;
import static org.junit.Assert.*;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
public class GithubUrlTest {
@Before
public void setUp() throws Exception {
}
@After
public void tearDown() throws Exception {
}
@Test
public final void testBaseUrlWithTree() {
GithubUrl url = new GithubUrl(
"http://github.com/juretta/iphone-project-tools/tree/master");
assertEquals("http://github.com/juretta/iphone-project-tools/", url
.baseUrl());
url = new GithubUrl(
"http://github.com/juretta/iphone-project-tools/tree/unstable");
assertEquals("http://github.com/juretta/iphone-project-tools/", url
.baseUrl());
}
@Test
public final void testBaseUrl() {
GithubUrl url = new GithubUrl(
"http://github.com/juretta/iphone-project-tools");
assertEquals("http://github.com/juretta/iphone-project-tools/", url
.baseUrl());
}
@Test
public final void testCommitId() {
GithubUrl url = new GithubUrl(
"http://github.com/juretta/hudson-github-plugin/tree/master");
assertEquals(
"http://github.com/juretta/hudson-github-plugin/commit/5e31203faea681c41577b685818a361089fac1fc",
url.commitId("5e31203faea681c41577b685818a361089fac1fc"));
}
}