Java tutorial
/** * Copyright 2005-2016 Red Hat, Inc. * * Red Hat licenses this file to you under the Apache License, version * 2.0 (the "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or * implied. See the License for the specific language governing * permissions and limitations under the License. */ package io.fabric8.devops.connector; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; import io.fabric8.devops.ProjectConfig; import io.fabric8.devops.ProjectConfigs; import io.fabric8.devops.ProjectRepositories; import io.fabric8.gerrit.CreateRepositoryDTO; import io.fabric8.kubernetes.api.Annotations; import io.fabric8.kubernetes.api.Controller; import io.fabric8.kubernetes.api.KubernetesHelper; import io.fabric8.kubernetes.api.ServiceNames; import io.fabric8.kubernetes.api.builds.Builds; import io.fabric8.kubernetes.api.model.ConfigMap; import io.fabric8.kubernetes.api.model.LocalObjectReference; import io.fabric8.kubernetes.api.model.ObjectMeta; import io.fabric8.kubernetes.client.Config; import io.fabric8.kubernetes.client.ConfigBuilder; import io.fabric8.kubernetes.client.DefaultKubernetesClient; import io.fabric8.kubernetes.client.KubernetesClient; import io.fabric8.letschat.LetsChatClient; import io.fabric8.letschat.LetsChatKubernetes; import io.fabric8.letschat.RoomDTO; import io.fabric8.openshift.api.model.BuildConfig; import io.fabric8.openshift.api.model.BuildConfigSpec; import io.fabric8.openshift.api.model.BuildSource; import io.fabric8.openshift.api.model.GitBuildSource; import io.fabric8.openshift.client.OpenShiftClient; import io.fabric8.project.support.GitUtils; import io.fabric8.repo.git.GitRepoClient; import io.fabric8.repo.git.GitRepoKubernetes; import io.fabric8.taiga.ModuleDTO; import io.fabric8.taiga.ProjectDTO; import io.fabric8.taiga.TaigaClient; import io.fabric8.taiga.TaigaKubernetes; import io.fabric8.taiga.TaigaModule; import io.fabric8.utils.DomHelper; import io.fabric8.utils.GitHelpers; import io.fabric8.utils.IOHelpers; import io.fabric8.utils.Objects; import io.fabric8.utils.Strings; import io.fabric8.utils.Systems; import io.fabric8.utils.URLUtils; import org.apache.http.Header; import org.apache.http.HttpEntity; import org.apache.http.HttpResponse; import org.apache.http.HttpStatus; import org.apache.http.auth.AUTH; import org.apache.http.auth.AuthenticationException; import org.apache.http.auth.MalformedChallengeException; import org.apache.http.auth.UsernamePasswordCredentials; import org.apache.http.client.HttpResponseException; import org.apache.http.client.ResponseHandler; import org.apache.http.client.methods.HttpGet; import org.apache.http.client.methods.HttpPost; import org.apache.http.entity.StringEntity; import org.apache.http.impl.auth.DigestScheme; import org.apache.http.impl.client.BasicResponseHandler; import org.apache.http.impl.client.CloseableHttpClient; import org.apache.http.impl.client.HttpClients; import org.json.JSONObject; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.w3c.dom.Document; import org.w3c.dom.Element; import org.w3c.dom.Node; import org.w3c.dom.NodeList; import org.xml.sax.InputSource; import org.xml.sax.SAXException; import javax.annotation.Priority; import javax.ws.rs.WebApplicationException; import javax.ws.rs.ext.ReaderInterceptor; import javax.ws.rs.ext.ReaderInterceptorContext; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import javax.xml.parsers.ParserConfigurationException; import java.io.BufferedReader; import java.io.ByteArrayInputStream; import java.io.File; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStreamWriter; import java.io.StringReader; import java.net.ConnectException; import java.net.HttpURLConnection; import java.net.URL; import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; import java.util.List; import java.util.Map; import static io.fabric8.kubernetes.api.KubernetesHelper.getOrCreateMetadata; /** * Updates a project's connections to its various DevOps resources like issue tracking, chat and jenkins builds */ public class DevOpsConnector { private transient Logger log = LoggerFactory.getLogger(DevOpsConnector.class); private static final String JSON_MAGIC = ")]}'"; private static final ObjectMapper MAPPER = new ObjectMapper(); private File basedir; private ProjectConfig projectConfig; private String username; private String password; private String branch; private String repoName; private String fullName; private String gitUrl; private String localGitUrl; private String secret = Builds.DEFAULT_SECRET; private String buildImageStream = Builds.DEFAULT_BUILD_IMAGE_STREAM; private String buildImageTag = Builds.DEFAULT_IMAGE_TAG; private String s2iCustomBuilderImage = Builds.DEFAULT_CUSTOM_BUILDER_IMAGE; private String jenkinsJob; private boolean triggerJenkinsJob = true; private String jenkinsMonitorView; private String jenkinsPipelineView; private String taigaProjectName; private String taigaProjectSlug; private String taigaProjectLinkPage = "backlog"; private String taigaProjectLinkLabel = "Backlog"; private String issueTrackerUrl; private String issueTrackerLabel = "Issues"; private String teamUrl; private String teamLabel = "Team"; private String releasesUrl; private String releasesLabel = "Releases"; private String repositoryBrowseLink; private String repositoryBrowseLabel = "Repository"; private String taigaTeamLinkPage = "team"; private String taigaTeamLinkLabel = "Team"; private boolean taigaAutoCreate = true; private boolean taigaEnabled = true; private boolean letschatEnabled = true; private String letschatRoomLinkLabel = "Room"; private String letschatRoomExpression = "fabric8_${namespace}"; private String flowGitUrl = Systems.getEnvVar("JENKINS_WORKFLOW_GIT_REPOSITORY", "https://github.com/fabric8io/jenkins-workflow-library.git"); private String gerritUser = Systems.getEnvVar("GERRIT_ADMIN_USER", "admin"); private String gerritPwd = Systems.getEnvVar("GERRIT_ADMIN_PWD", "secret"); private String gerritGitInitialCommit = Systems.getEnvVar("GERRIT_INITIAL_COMMIT", "false"); private String gerritGitRepoDesription = Systems.getEnvVar("GERRIT_REPO_DESCRIPTION", "Description of the gerrit git repo"); private boolean recreateMode; private String namespace = KubernetesHelper.defaultNamespace(); private String projectName; private String fabric8ConsoleNamespace = KubernetesHelper.defaultNamespace(); private String jenkinsNamespace = KubernetesHelper.defaultNamespace(); private boolean tryLoadConfigFileFromRemoteGit = true; private boolean modifiedConfig; private boolean registerWebHooks; private GitRepoClient gitRepoClient; private KubernetesClient kubernetes; private String jenkinsJobUrl; private ProjectDTO taigaProject; private TaigaClient taiga; private String jenkinsJobName; private String gitSourceSecretName; private String jenkinsJobTemplate; private boolean localJenkinsFlow; @Override public String toString() { return "DevOpsConnector{" + "gitUrl='" + gitUrl + '\'' + ", basedir=" + basedir + ", username='" + username + '\'' + ", branch='" + branch + '\'' + ", repoName='" + repoName + '\'' + '}'; } /** * For a given project this operation will try to update the associated DevOps resources * * @throws Exception */ public void execute() throws Exception { loadConfigFile(); KubernetesClient kubernetes = getKubernetes(); String name = projectName; if (Strings.isNullOrBlank(name)) { if (projectConfig != null) { name = projectConfig.getBuildName(); } if (Strings.isNullOrBlank(name)) { name = jenkinsJob; } if (Strings.isNullOrBlank(name)) { name = ProjectRepositories.createBuildName(username, repoName); if (projectConfig != null) { projectConfig.setBuildName(name); } } } if (Strings.isNullOrBlank(projectName)) { projectName = name; } Map<String, String> labels = new HashMap<>(); labels.put("user", username); labels.put("repo", repoName); getLog().info("build name " + name); taiga = null; taigaProject = null; try { taiga = createTaiga(); taigaProject = createTaigaProject(taiga); } catch (Exception e) { getLog().error("Failed to load or lazily create the Taiga project: " + e, e); } getLog().info("taiga " + taiga); LetsChatClient letschat = null; try { letschat = createLetsChat(); } catch (Exception e) { getLog().error("Failed to load or lazily create the LetsChat client: " + e, e); } getLog().info("letschat " + letschat); /* * Create Gerrit Git to if isGerritReview is enabled */ if (projectConfig != null && projectConfig.hasCodeReview()) { try { createGerritRepo(repoName, gerritUser, gerritPwd, gerritGitInitialCommit, gerritGitRepoDesription); } catch (Exception e) { getLog().error("Failed to create GerritGit repo : " + e, e); } } Map<String, String> annotations = new HashMap<>(); jenkinsJobUrl = null; String jenkinsUrl = null; try { jenkinsUrl = getJenkinsServiceUrl(true); if (Strings.isNotBlank(jenkinsUrl)) { if (Strings.isNotBlank(jenkinsMonitorView)) { String url = URLUtils.pathJoin(jenkinsUrl, "/view", jenkinsMonitorView); annotationLink(annotations, "fabric8.link.jenkins.monitor/", url, "Monitor"); } if (Strings.isNotBlank(jenkinsPipelineView)) { String url = URLUtils.pathJoin(jenkinsUrl, "/view", jenkinsPipelineView); annotationLink(annotations, "fabric8.link.jenkins.pipeline/", url, "Pipeline"); } if (Strings.isNotBlank(name)) { jenkinsJobUrl = URLUtils.pathJoin(jenkinsUrl, "/job", name); annotationLink(annotations, "fabric8.link.jenkins.job/", jenkinsJobUrl, "Job"); } } } catch (Exception e) { getLog().warn("Could not find the Jenkins URL!: " + e, e); } getLog().info("jenkins " + jenkinsUrl); if (!annotationLink(annotations, "fabric8.link.issues/", issueTrackerUrl, issueTrackerLabel)) { String taigaLink = getProjectPageLink(taiga, taigaProject, this.taigaProjectLinkPage); annotationLink(annotations, "fabric8.link.taiga/", taigaLink, taigaProjectLinkLabel); } if (!annotationLink(annotations, "fabric8.link.team/", teamUrl, teamLabel)) { String taigaTeamLink = getProjectPageLink(taiga, taigaProject, this.taigaTeamLinkPage); annotationLink(annotations, "fabric8.link.taiga.team/", taigaTeamLink, taigaTeamLinkLabel); } annotationLink(annotations, "fabric8.link.releases/", releasesUrl, releasesLabel); String chatRoomLink = getChatRoomLink(letschat); annotationLink(annotations, "fabric8.link.letschat.room/", chatRoomLink, letschatRoomLinkLabel); annotationLink(annotations, "fabric8.link.repository.browse/", repositoryBrowseLink, repositoryBrowseLabel); ProjectConfigs.defaultEnvironments(projectConfig, namespace); String consoleUrl = getServiceUrl(ServiceNames.FABRIC8_CONSOLE, namespace, fabric8ConsoleNamespace); if (projectConfig != null) { Map<String, String> environments = projectConfig.getEnvironments(); updateEnvironmentConfigMap(environments, kubernetes, annotations, consoleUrl); } addLink("Git", getGitUrl()); Controller controller = createController(); OpenShiftClient openShiftClient = controller.getOpenShiftClientOrJenkinshift(); BuildConfig buildConfig = null; if (openShiftClient != null) { try { buildConfig = openShiftClient.buildConfigs().withName(projectName).get(); } catch (Exception e) { log.error("Failed to load build config for " + namespace + "/" + projectName + ". " + e, e); } log.info("Loaded build config for " + namespace + "/" + projectName + " " + buildConfig); } // if we have loaded a build config then lets assume its correct! boolean foundExistingGitUrl = false; if (buildConfig != null) { BuildConfigSpec spec = buildConfig.getSpec(); if (spec != null) { BuildSource source = spec.getSource(); if (source != null) { GitBuildSource git = source.getGit(); if (git != null) { gitUrl = git.getUri(); log.info("Loaded existing BuildConfig git url: " + gitUrl); foundExistingGitUrl = true; } LocalObjectReference sourceSecret = source.getSourceSecret(); if (sourceSecret != null) { gitSourceSecretName = sourceSecret.getName(); } } } if (!foundExistingGitUrl) { log.warn("Could not find a git url in the loaded BuildConfig: " + buildConfig); } log.info("Loaded gitSourceSecretName: " + gitSourceSecretName); } log.info("gitUrl is: " + gitUrl); if (buildConfig == null) { buildConfig = new BuildConfig(); } ObjectMeta metadata = getOrCreateMetadata(buildConfig); metadata.setName(projectName); metadata.setLabels(labels); putAnnotations(metadata, annotations); Map<String, String> currentAnnotations = metadata.getAnnotations(); if (!currentAnnotations.containsKey(Annotations.Builds.GIT_CLONE_URL)) { currentAnnotations.put(Annotations.Builds.GIT_CLONE_URL, gitUrl); } String localGitUrl = getLocalGitUrl(); if (!currentAnnotations.containsKey(Annotations.Builds.LOCAL_GIT_CLONE_URL) && Strings.isNotBlank(localGitUrl)) { currentAnnotations.put(Annotations.Builds.LOCAL_GIT_CLONE_URL, localGitUrl); } // lets switch to the local git URL to avoid DNS issues in forge or jenkins if (Strings.isNotBlank(localGitUrl)) { gitUrl = localGitUrl; } Builds.configureDefaultBuildConfig(buildConfig, name, gitUrl, foundExistingGitUrl, buildImageStream, buildImageTag, s2iCustomBuilderImage, secret, jenkinsUrl); try { getLog().info("About to apply build config: " + new JSONObject(KubernetesHelper.toJson(buildConfig)).toString(4)); controller.applyBuildConfig(buildConfig, "maven"); getLog().info("Created build configuration for " + name + " in namespace: " + controller.getNamespace() + " at " + kubernetes.getMasterUrl()); } catch (Exception e) { getLog().error("Failed to create BuildConfig for " + KubernetesHelper.toJson(buildConfig) + ". " + e, e); } this.jenkinsJobName = name; if (isRegisterWebHooks()) { registerWebHooks(); getLog().info("webhooks done"); } if (modifiedConfig) { if (basedir == null) { getLog().error("Could not save updated " + ProjectConfigs.FILE_NAME + " due to missing basedir"); } else { try { ProjectConfigs.saveToFolder(basedir, projectConfig, true); getLog().info("Updated " + ProjectConfigs.FILE_NAME); } catch (IOException e) { getLog().error("Could not save updated " + ProjectConfigs.FILE_NAME + ": " + e, e); } } } } private void putAnnotations(ObjectMeta metadata, Map<String, String> annotations) { Map<String, String> current = metadata.getAnnotations(); if (current == null) { current = new HashMap<>(); } for (Map.Entry<String, String> entry : annotations.entrySet()) { String key = entry.getKey(); String value = entry.getValue(); current.put(key, value); } metadata.setAnnotations(current); } protected String getLocalGitUrl() { return localGitUrl; } public void updateEnvironmentConfigMap(Map<String, String> environments, KubernetesClient kubernetes, Map<String, String> annotations, String consoleUrl) { if (environments != null && !environments.isEmpty()) { String name = Environments.ENVIRONMENTS_CONFIG_MAP_NAME; getLog().info("Ensuring ConfigMap " + name + " is populated with enviroments: " + environments); ConfigMap environmentsConfigMap = Environments.getOrCreateEnvironments(kubernetes); boolean updatedEnvConfigMap = false; for (Map.Entry<String, String> entry : environments.entrySet()) { String label = entry.getKey(); String value = entry.getValue(); String key = value; annotations.put("fabric8.link.environment." + key + "/label", label); if (Strings.isNotBlank(consoleUrl)) { String environmentLink = URLUtils.pathJoin(consoleUrl, "/kubernetes/pods?namespace=" + value); annotations.put("fabric8.link.environment." + key + "/url", environmentLink); addLink(label, environmentLink); } String dataKey = label.toLowerCase().replace(' ', '-'); boolean updated = Environments.ensureEnvironmentAdded(environmentsConfigMap, dataKey, label, value); updatedEnvConfigMap = updated || updatedEnvConfigMap; } if (updatedEnvConfigMap) { String ns = kubernetes.getNamespace(); getLog().info("Updating ConfigMap " + name + " with data: " + environmentsConfigMap.getData()); if (KubernetesHelper.getResourceVersion(environmentsConfigMap) == null) { kubernetes.configMaps().inNamespace(ns).create(environmentsConfigMap); } else { try { kubernetes.configMaps().inNamespace(ns).withName(name).replace(environmentsConfigMap); } catch (Exception e) { getLog().error("Failed to update the Environment ConfigMap with data: " + environments + ". Reason: " + e, e); } } } else { getLog().info("No need to update ConfigMap " + name + " as already has data: " + environmentsConfigMap.getData()); } } } protected String getJenkinsServiceUrl(boolean externalUrl) { return getServiceUrl(ServiceNames.JENKINS, externalUrl, namespace, jenkinsNamespace); } /** * Looks in the given namespaces for the given service or returns null if it could not be found */ protected String getServiceUrl(String serviceName, String... namespaces) { return getServiceUrl(serviceName, false, namespaces); } private String getServiceUrl(String serviceName, boolean serviceExternal, String... namespaces) { List<String> namespaceList = new ArrayList<>(Arrays.asList(namespaces)); String[] defaults = { KubernetesHelper.defaultNamespace(), "default" }; for (String defaultNamespace : defaults) { if (namespaceList.contains(defaultNamespace)) { namespaceList.add(defaultNamespace); } } for (String namespace : namespaceList) { try { return KubernetesHelper.getServiceURL(getKubernetes(), serviceName, namespace, "http", serviceExternal); } catch (Exception e) { // ignore } } return null; } protected boolean annotationLink(Map<String, String> annotations, String annotationPrefix, String issueTrackerUrl, String issueTrackerLabel) { if (Strings.isNotBlank(issueTrackerUrl)) { annotations.put(annotationPrefix + "url", issueTrackerUrl); annotations.put(annotationPrefix + "label", issueTrackerLabel); addLink(issueTrackerLabel, issueTrackerUrl); return true; } else { return false; } } public void registerWebHooks() { if (Strings.isNotBlank(jenkinsJobName)) { jenkinsJobTemplate = createJenkinsJob(jenkinsJobName, jenkinsJobUrl); getLog().info("created jenkins job"); } if (Strings.isNotBlank(jenkinsJobUrl) && Strings.isNotBlank(jenkinsJobName)) { createJenkinsWebhook(jenkinsJobUrl); } if (taiga != null && taigaProject != null) { createTaigaWebhook(taiga, taigaProject); } } public void addLink(String label, String url) { if (projectConfig == null) { projectConfig = new ProjectConfig(); } projectConfig.addLink(label, url); modifiedConfig = true; } public Logger getLog() { return log; } public void setLog(Logger log) { this.log = log; } public KubernetesClient getKubernetes() { if (kubernetes == null) { Config config = new ConfigBuilder().withNamespace(namespace).build(); kubernetes = new DefaultKubernetesClient(config); } return kubernetes; } public GitRepoClient getGitRepoClient() { if (gitRepoClient == null) { gitRepoClient = GitRepoKubernetes.createGitRepoClient(getKubernetes(), username, password); if (gitRepoClient != null) { if (Strings.isNullOrBlank(username)) { username = gitRepoClient.getUsername(); } if (Strings.isNullOrBlank(password)) { password = gitRepoClient.getPassword(); } } } return gitRepoClient; } // Properties //------------------------------------------------------------------------- public File getBasedir() { return basedir; } public void setBasedir(File basedir) { this.basedir = basedir; } public String getBranch() { return branch; } public void setBranch(String branch) { this.branch = branch; } public String getBuildImageStream() { return buildImageStream; } public void setBuildImageStream(String buildImageStream) { this.buildImageStream = buildImageStream; } public String getBuildImageTag() { return buildImageTag; } public void setBuildImageTag(String buildImageTag) { this.buildImageTag = buildImageTag; } public String getFullName() { return fullName; } public void setFullName(String fullName) { this.fullName = fullName; } public void setGitRepoClient(GitRepoClient gitRepoClient) { this.gitRepoClient = gitRepoClient; } public String getGitUrl() { return gitUrl; } public void setGitUrl(String gitUrl) { this.gitUrl = gitUrl; } public void setLocalGitUrl(String localGitUrl) { this.localGitUrl = localGitUrl; } public String getJenkinsJob() { return jenkinsJob; } public void setJenkinsJob(String jenkinsJob) { this.jenkinsJob = jenkinsJob; } public String getJenkinsMonitorView() { return jenkinsMonitorView; } public void setJenkinsMonitorView(String jenkinsMonitorView) { this.jenkinsMonitorView = jenkinsMonitorView; } public String getJenkinsPipelineView() { return jenkinsPipelineView; } public void setJenkinsPipelineView(String jenkinsPipelineView) { this.jenkinsPipelineView = jenkinsPipelineView; } public void setKubernetes(KubernetesClient kubernetes) { this.kubernetes = kubernetes; } public boolean isTriggerJenkinsJob() { return triggerJenkinsJob; } public void setTriggerJenkinsJob(boolean triggerJenkinsJob) { this.triggerJenkinsJob = triggerJenkinsJob; } public boolean isLetschatEnabled() { return letschatEnabled; } public void setLetschatEnabled(boolean letschatEnabled) { this.letschatEnabled = letschatEnabled; } public String getLetschatRoomExpression() { return letschatRoomExpression; } public void setLetschatRoomExpression(String letschatRoomExpression) { this.letschatRoomExpression = letschatRoomExpression; } public String getLetschatRoomLinkLabel() { return letschatRoomLinkLabel; } public void setLetschatRoomLinkLabel(String letschatRoomLinkLabel) { this.letschatRoomLinkLabel = letschatRoomLinkLabel; } public String getNamespace() { return namespace; } public void setNamespace(String namespace) { this.namespace = namespace; } public String getFabric8ConsoleNamespace() { return fabric8ConsoleNamespace; } public void setFabric8ConsoleNamespace(String fabric8ConsoleNamespace) { this.fabric8ConsoleNamespace = fabric8ConsoleNamespace; } public String getJenkinsNamespace() { return jenkinsNamespace; } public void setJenkinsNamespace(String jenkinsNamespace) { this.jenkinsNamespace = jenkinsNamespace; } public String getPassword() { return password; } public void setPassword(String password) { this.password = password; } public boolean isRecreateMode() { return recreateMode; } public void setRecreateMode(boolean recreateMode) { this.recreateMode = recreateMode; } public String getRepoName() { return repoName; } public void setRepoName(String repoName) { this.repoName = repoName; } public String getSecret() { return secret; } public void setSecret(String secret) { this.secret = secret; } public boolean isTaigaAutoCreate() { return taigaAutoCreate; } public void setTaigaAutoCreate(boolean taigaAutoCreate) { this.taigaAutoCreate = taigaAutoCreate; } public boolean isTaigaEnabled() { return taigaEnabled; } public void setTaigaEnabled(boolean taigaEnabled) { this.taigaEnabled = taigaEnabled; } public String getTaigaProjectLinkLabel() { return taigaProjectLinkLabel; } public void setTaigaProjectLinkLabel(String taigaProjectLinkLabel) { this.taigaProjectLinkLabel = taigaProjectLinkLabel; } public String getTaigaProjectLinkPage() { return taigaProjectLinkPage; } public void setTaigaProjectLinkPage(String taigaProjectLinkPage) { this.taigaProjectLinkPage = taigaProjectLinkPage; } public String getTaigaProjectName() { return taigaProjectName; } public void setTaigaProjectName(String taigaProjectName) { this.taigaProjectName = taigaProjectName; } public String getTaigaProjectSlug() { return taigaProjectSlug; } public void setTaigaProjectSlug(String taigaProjectSlug) { this.taigaProjectSlug = taigaProjectSlug; } public String getTaigaTeamLinkLabel() { return taigaTeamLinkLabel; } public void setTaigaTeamLinkLabel(String taigaTeamLinkLabel) { this.taigaTeamLinkLabel = taigaTeamLinkLabel; } public String getTaigaTeamLinkPage() { return taigaTeamLinkPage; } public void setTaigaTeamLinkPage(String taigaTeamLinkPage) { this.taigaTeamLinkPage = taigaTeamLinkPage; } public String getUsername() { return username; } public void setUsername(String username) { this.username = username; } public boolean isTryLoadConfigFileFromRemoteGit() { return tryLoadConfigFileFromRemoteGit; } public void setTryLoadConfigFileFromRemoteGit(boolean tryLoadConfigFileFromRemoteGit) { this.tryLoadConfigFileFromRemoteGit = tryLoadConfigFileFromRemoteGit; } public ProjectConfig getProjectConfig() { return projectConfig; } public void setProjectConfig(ProjectConfig projectConfig) { this.projectConfig = projectConfig; } public void setRegisterWebHooks(boolean registerWebHooks) { this.registerWebHooks = registerWebHooks; } public boolean isRegisterWebHooks() { return registerWebHooks; } public String getIssueTrackerLabel() { return issueTrackerLabel; } public void setIssueTrackerLabel(String issueTrackerLabel) { this.issueTrackerLabel = issueTrackerLabel; } public String getIssueTrackerUrl() { return issueTrackerUrl; } public void setIssueTrackerUrl(String issueTrackerUrl) { this.issueTrackerUrl = issueTrackerUrl; } public String getTeamUrl() { return teamUrl; } public void setTeamUrl(String teamUrl) { this.teamUrl = teamUrl; } public String getTeamLabel() { return teamLabel; } public void setTeamLabel(String teamLabel) { this.teamLabel = teamLabel; } public String getReleasesUrl() { return releasesUrl; } public void setReleasesUrl(String releasesUrl) { this.releasesUrl = releasesUrl; } public String getReleasesLabel() { return releasesLabel; } public void setReleasesLabel(String releasesLabel) { this.releasesLabel = releasesLabel; } public String getRepositoryBrowseLabel() { return repositoryBrowseLabel; } public void setRepositoryBrowseLabel(String repositoryBrowseLabel) { this.repositoryBrowseLabel = repositoryBrowseLabel; } public String getRepositoryBrowseLink() { return repositoryBrowseLink; } public void setRepositoryBrowseLink(String repositoryBrowseLink) { this.repositoryBrowseLink = repositoryBrowseLink; } public String getProjectName() { return projectName; } public void setProjectName(String projectName) { this.projectName = projectName; } // Implementation methods //------------------------------------------------------------------------- protected Controller createController() { Controller controller = new Controller(getKubernetes()); controller.setNamespace(namespace); controller.setThrowExceptionOnError(true); controller.setRecreateMode(recreateMode); return controller; } protected void loadConfigFile() { if (projectConfig == null) { GitRepoClient gitRepo = getGitRepoClient(); boolean hasLocalConfig = false; if (basedir != null && basedir.isDirectory()) { projectConfig = ProjectConfigs.loadFromFolder(basedir); if (!projectConfig.isEmpty() || ProjectConfigs.hasConfigFile(basedir)) { hasLocalConfig = true; } } if (!hasLocalConfig && tryLoadConfigFileFromRemoteGit && Strings.isNotBlank(repoName) && gitRepo != null) { try { InputStream input = gitRepo.getRawFile(username, repoName, branch, ProjectConfigs.FILE_NAME); if (input != null) { try { getLog().info("Parsing " + ProjectConfigs.FILE_NAME + " from the git repo " + repoName + " user " + username + " in branch " + branch); projectConfig = ProjectConfigs.parseProjectConfig(input); } catch (IOException e) { getLog().warn("Failed to parse " + ProjectConfigs.FILE_NAME + " from the repo " + repoName + " for user " + username + " branch: " + branch + ". " + e, e); } } } catch (Exception e) { getLog().warn("Failed to load " + ProjectConfigs.FILE_NAME + " from the repo " + repoName + " for user " + username + " branch: " + branch + ". " + e, e); } } } if (projectConfig != null) { String chatRoom = projectConfig.getChatRoom(); if (Strings.isNotBlank(chatRoom)) { getLog().info("Found chat room: " + chatRoom); letschatRoomExpression = chatRoom; } String issueProjectName = projectConfig.getIssueProjectName(); if (Strings.isNotBlank(issueProjectName)) { taigaProjectName = issueProjectName; } } else { getLog().info("No fabric8.yml file found for " + basedir); } if (Strings.isNullOrBlank(gitUrl)) { try { gitUrl = GitHelpers.extractGitUrl(basedir); } catch (IOException e) { getLog().warn("Could not load git URL from directory: " + e, e); } } if (Strings.isNullOrBlank(taigaProjectName)) { taigaProjectName = repoName; } if (Strings.isNullOrBlank(taigaProjectSlug)) { // TODO should we upper case it or anything? taigaProjectSlug = taigaProjectName; } } protected String getChatRoomLink(LetsChatClient letschat) { if (letschat != null) { try { String url = letschat.getAddress(); String slug = evaluateRoomExpression(letschatRoomExpression); if (Strings.isNotBlank(url) && Strings.isNotBlank(slug)) { RoomDTO room = letschat.getOrCreateRoom(slug); if (room != null) { String roomId = room.getId(); if (Strings.isNotBlank(roomId)) { return URLUtils.pathJoin(url, "/#!/room/" + roomId); } } } } catch (Exception e) { getLog().error("Failed to get the link to the chat room: " + e, e); } } return null; } protected String evaluateRoomExpression(String roomExpresion) { if (Strings.isNotBlank(roomExpresion)) { String namespace = KubernetesHelper.defaultNamespace(); String answer = roomExpresion; answer = replaceExpression(answer, "namespace", namespace); answer = replaceExpression(answer, "repoName", repoName); answer = replaceExpression(answer, "username", username); return answer; } else { return null; } } protected String replaceExpression(String text, String key, String value) { if (Strings.isNotBlank(key) && Strings.isNotBlank(value)) { String replace = "${" + key + "}"; return text.replace(replace, value); } else { return text; } } protected LetsChatClient createLetsChat() { if (!letschatEnabled) { return null; } KubernetesClient kubernetes = getKubernetes(); LetsChatClient letsChat = LetsChatKubernetes.createLetsChat(kubernetes); if (letsChat == null) { getLog().warn("No letschat service availble n kubernetes " + namespace + " on address: " + kubernetes.getMasterUrl()); return null; } if (!letsChat.isValid()) { getLog().warn("No $" + LetsChatKubernetes.LETSCHAT_HUBOT_TOKEN + " environment variable defined so LetsChat support is disabled"); return null; } return letsChat; } protected TaigaClient createTaiga() { if (!taigaEnabled) { return null; } TaigaClient taiga = TaigaKubernetes.createTaiga(getKubernetes(), namespace); if (taiga != null) { taiga.setAutoCreateProjects(taigaAutoCreate); } return taiga; } protected String getProjectPageLink(TaigaClient taiga, ProjectDTO taigaProject, String projectRelativePage) { if (taiga != null && taigaProject != null) { try { String url = taiga.getAddress(); String slug = taigaProject.getSlug(); if (Strings.isNullOrBlank(slug)) { slug = taigaProjectSlug; } String userName = taiga.getUsername(); if (Strings.isNullOrBlank(slug)) { slug = userName + "-" + taigaProjectName; } if (Strings.isNotBlank(url) && Strings.isNotBlank(slug) && Strings.isNotBlank(projectRelativePage)) { return URLUtils.pathJoin(url, "/project/", slug + "/", projectRelativePage); } } catch (Exception e) { getLog().error("Failed to get project page link for " + projectRelativePage + " : " + e, e); } } return null; } protected String createJenkinsJob(String buildName, String jenkinsJobUrl) { String answer = null; if (projectConfig != null) { String flow = projectConfig.getPipeline(); String flowGitUrlValue = null; boolean localFlow = false; String projectGitUrl = this.gitUrl; if (Strings.isNotBlank(flow)) { flowGitUrlValue = this.flowGitUrl; } else if (projectConfig.isUseLocalFlow()) { flow = ProjectConfigs.LOCAL_FLOW_FILE_NAME; flowGitUrlValue = projectGitUrl; localFlow = true; } else { getLog().info("Not creating Jenkins job as no pipeline defined for project configuration!"); } this.localJenkinsFlow = localFlow; String versionPrefix = Systems.getSystemPropertyOrEnvVar("VERSION_PREFIX", "VERSION_PREFIX", "1.0"); if (Strings.isNotBlank(flow) && Strings.isNotBlank(projectGitUrl) && Strings.isNotBlank(flowGitUrlValue)) { String template = loadJenkinsBuildTemplate(getLog()); if (Strings.isNotBlank(template)) { if (Strings.isNotBlank(gitSourceSecretName)) { template = addBuildParameter(getLog(), template, "SOURCE_SECRET", gitSourceSecretName, "Name of the Kubernetes Secret required to clone the git repository"); } template = template.replace("${FLOW_PATH}", flow); template = template.replace("${FLOW_GIT_URL}", flowGitUrlValue); template = template.replace("${GIT_URL}", projectGitUrl); template = template.replace("${VERSION_PREFIX}", versionPrefix); if (localFlow) { // lets remove the GIT_URL parameter template = removeBuildParameter(getLog(), template, "GIT_URL"); } postJenkinsBuild(buildName, template, true); answer = template; } } addProjectSecret(); } return answer; } private void addProjectSecret() { } protected void addJenkinsScmTrigger(String jenkinsJobUrl) { if (Strings.isNullOrBlank(jenkinsJobTemplate)) { getLog().warn("Cannot add SCM trigger to jenkins job at " + jenkinsJobUrl + " as there is no cached template"); } else if (!localJenkinsFlow) { getLog().info("Not adding an SCM trigger to jenkins job at " + jenkinsJobUrl + " as it is not using a local Jenkinsfile"); } else { getLog().info("Adding adding an SCM trigger to jenkins job at " + jenkinsJobUrl); String template = null; try { template = jenkinsJobTemplate; Document doc = parseXmlText(template); Element rootElement = doc.getDocumentElement(); Element triggerElement = null; NodeList triggers = rootElement.getElementsByTagName("triggers"); if (triggers == null || triggers.getLength() == 0) { triggerElement = DomHelper.addChildElement(rootElement, "triggers"); } else { triggerElement = (Element) triggers.item(0); } String hostName = GitUtils.getGitHostName(gitUrl); getLog().info("using git host: " + hostName); if (Objects.equal("github.com", hostName)) { Element githubTrigger = DomHelper.firstChild(triggerElement, "com.cloudbees.jenkins.GitHubPushTrigger"); if (githubTrigger == null) { githubTrigger = DomHelper.addChildElement(triggerElement, "com.cloudbees.jenkins.GitHubPushTrigger"); githubTrigger.setAttribute("plugin", "github@1.14.0"); DomHelper.addChildElement(githubTrigger, "spec"); } } Element scmTrigger = DomHelper.addChildElement(triggerElement, "hudson.triggers.SCMTrigger"); DomHelper.addChildElement(scmTrigger, "spec", "* * * * * "); DomHelper.addChildElement(scmTrigger, "ignorePostCommitHooks", "false"); template = DomHelper.toXml(doc); } catch (Exception e) { getLog().warn("Failed to add the SCM trigger to jenkins job at " + jenkinsJobUrl + ". Reason: " + e, e); template = null; } if (Strings.isNotBlank(template)) { postJenkinsBuild(jenkinsJobName, template, false); } } } public static String loadJenkinsBuildTemplate(Logger log) { String template = null; String templateName = "jenkinsBuildConfig.xml"; URL url = DevOpsConnector.class.getResource(templateName); if (url == null) { log.error("Could not load " + templateName + " on the classpath!"); } else { try { template = IOHelpers.loadFully(url); } catch (IOException e) { log.error("Failed to load template " + templateName + " from " + url + ". " + e, e); } } return template; } public static String addBuildParameter(Logger log, String template, String parameterName, String parameterValue, String description) { try { Document doc = parseXmlText(template); Element rootElement = doc.getDocumentElement(); NodeList parameterDefs = rootElement.getElementsByTagName("parameterDefinitions"); if (parameterDefs != null && parameterDefs.getLength() > 0) { Node paramDefNode = parameterDefs.item(0); Element stringParamDef = DomHelper.addChildElement(paramDefNode, "hudson.model.StringParameterDefinition"); DomHelper.addChildElement(stringParamDef, "name", parameterName); DomHelper.addChildElement(stringParamDef, "defaultValue", parameterValue); if (Strings.isNotBlank(description)) { DomHelper.addChildElement(stringParamDef, "description", description); } return DomHelper.toXml(doc); } else { log.warn("Could not find the <parameterDefinitions> to add the build parameter name " + parameterName + " with value: " + parameterValue); } } catch (Exception e) { log.error("Failed to add the build parameter from the Jenkins XML. " + e, e); } return template; } protected static Document parseXmlText(String template) throws ParserConfigurationException, SAXException, IOException { DocumentBuilder documentBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder(); return documentBuilder.parse(new InputSource(new StringReader(template))); } public static String removeBuildParameter(Logger log, String template, String parameterName) { try { Document doc = parseXmlText(template); Element rootElement = doc.getDocumentElement(); NodeList stringDefs = rootElement.getElementsByTagName("hudson.model.StringParameterDefinition"); if (stringDefs != null) { for (int i = 0, size = stringDefs.getLength(); i < size; i++) { Node item = stringDefs.item(i); if (item instanceof Element) { Element element = (Element) item; Element name = DomHelper.firstChild(element, "name"); if (name != null) { String textContent = name.getTextContent(); if (textContent != null) { if (parameterName.equals(textContent.trim())) { Node parameterDefinitions = item.getParentNode(); Node parametersDefinitionProperty = parameterDefinitions != null ? parameterDefinitions.getParentNode() : null; DomHelper.detach(item); if (DomHelper.firstChildElement(parameterDefinitions) == null) { DomHelper.detach(parameterDefinitions); } if (DomHelper.firstChildElement(parametersDefinitionProperty) == null) { DomHelper.detach(parametersDefinitionProperty); } return DomHelper.toXml(doc); } } } } } } } catch (Exception e) { log.error("Failed to remove the build parameter from the Jenkins XML. " + e, e); } return template; } protected void postJenkinsBuild(String jobName, String xml, boolean create) { String address = getServiceUrl(ServiceNames.JENKINS, false, namespace, jenkinsNamespace); if (Strings.isNotBlank(address)) { String jobUrl = URLUtils.pathJoin(address, "/job", jobName, "config.xml"); if (create && !existsXmlURL(jobUrl)) { jobUrl = URLUtils.pathJoin(address, "/createItem") + "?name=" + jobName; } getLog().info("POSTING the jenkins job to: " + jobUrl); getLog().debug("Jenkins XML: " + xml); HttpURLConnection connection = null; try { URL url = new URL(jobUrl); connection = (HttpURLConnection) url.openConnection(); connection.setRequestMethod("POST"); connection.setRequestProperty("Content-Type", "text/xml"); connection.setDoOutput(true); OutputStreamWriter out = new OutputStreamWriter(connection.getOutputStream()); out.write(xml); out.close(); int status = connection.getResponseCode(); String message = connection.getResponseMessage(); getLog().info("Got response code from Jenkins: " + status + " message: " + message); if (status != 200) { getLog().error("Failed to register job " + jobName + " on " + jobUrl + ". Status: " + status + " message: " + message); } } catch (Exception e) { getLog().error("Failed to register jenkins on " + jobUrl + ". " + e, e); } finally { if (connection != null) { connection.disconnect(); } } } } /** * Checks if the given XML URL exists * * @return true if it does */ protected boolean existsXmlURL(String urlText) { // lets check that the job doesn't already exist! HttpURLConnection connection = null; try { URL url = new URL(urlText); connection = (HttpURLConnection) url.openConnection(); connection.setRequestMethod("GET"); connection.setRequestProperty("Accept", "application/xml"); int responseCode = connection.getResponseCode(); getLog().info("Checking URL exists got response code " + responseCode + " on url " + urlText); if (responseCode >= 200 && responseCode < 300) { return true; } } catch (Throwable e) { // ignore } return false; } protected void createJenkinsWebhook(String jenkinsJobUrl) { if (Strings.isNotBlank(jenkinsJobUrl)) { String jenkinsWebHook = URLUtils.pathJoin(jenkinsJobUrl, "/build"); Map<String, String> buildParameters = getBuildParameters(); if (!buildParameters.isEmpty()) { String postfix = ""; for (Map.Entry<String, String> entry : buildParameters.entrySet()) { if (postfix.length() > 0) { postfix += "&"; } postfix += entry.getKey() + "=" + entry.getValue(); } jenkinsWebHook += "WithParameters?" + postfix; } boolean created = createWebhook(jenkinsWebHook, this.secret); if (!created) { // lets try to update the Jenkins job to add a SCM polling trigger addJenkinsScmTrigger(jenkinsJobUrl); } // lets trigger the jenkins webhook URL on project creation if we couldn't register a webhook // e.g. if the project is hosted on github if (triggerJenkinsJob || !created) { triggerJenkinsWebHook(jenkinsJobUrl, jenkinsWebHook, this.secret); } } } protected void triggerJenkinsWebHook(String jobUrl, String triggerUrl, String secret) { // lets check if this build is already running in which case do nothing String lastBuild = URLUtils.pathJoin(jobUrl, "/lastBuild/api/json"); JsonNode lastBuildJson = parseLastBuildJson(lastBuild); JsonNode building = null; if (lastBuildJson != null && lastBuildJson.isObject()) { building = lastBuildJson.get("building"); if (building != null && building.isBoolean()) { if (building.booleanValue()) { getLog().info("Build is already running so lets not trigger another one!"); return; } } } getLog().info("Got last build JSON: " + lastBuildJson + " building: " + building); getLog().info("Triggering Jenkins webhook: " + triggerUrl); String json = "{}"; HttpURLConnection connection = null; try { URL url = new URL(triggerUrl); connection = (HttpURLConnection) url.openConnection(); connection.setRequestMethod("POST"); connection.setRequestProperty("Content-Type", "application/json"); connection.setDoOutput(true); OutputStreamWriter out = new OutputStreamWriter(connection.getOutputStream()); out.write(json); out.close(); int status = connection.getResponseCode(); String message = connection.getResponseMessage(); getLog().info("Got response code from Jenkins: " + status + " message: " + message); if (status != 200) { getLog().error( "Failed to trigger job " + triggerUrl + ". Status: " + status + " message: " + message); } } catch (Exception e) { getLog().error("Failed to trigger jenkins on " + triggerUrl + ". " + e, e); } finally { if (connection != null) { connection.disconnect(); } } } protected JsonNode parseLastBuildJson(String urlText) { HttpURLConnection connection = null; String message = null; try { URL url = new URL(urlText); connection = (HttpURLConnection) url.openConnection(); connection.setRequestMethod("GET"); connection.setRequestProperty("Content-Type", "application/json"); int status = connection.getResponseCode(); message = connection.getResponseMessage(); getLog().info("Got response code from URL: " + url + " " + status + " message: " + message); if (status != 200 || Strings.isNullOrBlank(message)) { getLog().debug("Failed to load URL " + url + ". Status: " + status + " message: " + message); } else { ObjectMapper objectMapper = new ObjectMapper(); return objectMapper.reader().readTree(message); } } catch (Exception e) { getLog().debug("Failed to load URL " + urlText + ". " + e, e); } finally { if (connection != null) { connection.disconnect(); } } return null; } /** * If the build is parameterised lets return the build parameters */ protected Map<String, String> getBuildParameters() { Map<String, String> answer = new HashMap<>(); if (projectConfig != null) { String flow = projectConfig.getPipeline(); if (flow != null && Strings.isNotBlank(gitUrl)) { answer.put("GIT_URL", gitUrl); } Map<String, String> parameters = projectConfig.getBuildParameters(); if (parameters != null) { answer.putAll(parameters); } if (!answer.containsKey("VERSION_PREFIX")) { answer.put("VERSION_PREFIX", "1.0"); } } return answer; } protected ProjectDTO createTaigaProject(TaigaClient taiga) { if (taiga != null) { if (Strings.isNullOrBlank(taigaProjectName)) { getLog().info("Not creating Taiga project as no `fabric8.tagiaProjectName` property specified"); return null; } if (Strings.isNullOrBlank(taigaProjectSlug)) { getLog().info("Not creating Taiga project as no `fabric8.taigaProjectSlug` property specified"); return null; } getLog().info("About to create Taiga project " + taigaProjectName + " with slug: " + taigaProjectSlug); return taiga.getOrCreateProject(taigaProjectName, taigaProjectSlug); } return null; } protected void createGerritRepo(String repoName, String gerritUser, String gerritPwd, String gerritGitInitialCommit, String gerritGitRepoDescription) throws Exception { // lets add defaults if not env vars if (Strings.isNullOrBlank(gerritUser)) { gerritUser = "admin"; } if (Strings.isNullOrBlank(gerritPwd)) { gerritPwd = "secret"; } log.info("A Gerrit git repo will be created for this name : " + repoName); String gerritAddress = KubernetesHelper.getServiceURL(kubernetes, ServiceNames.GERRIT, namespace, "http", true); log.info("Found gerrit address: " + gerritAddress + " for namespace: " + namespace + " on Kubernetes address: " + kubernetes.getMasterUrl()); if (Strings.isNullOrBlank(gerritAddress)) { throw new Exception("No address for service " + ServiceNames.GERRIT + " in namespace: " + namespace + " on Kubernetes address: " + kubernetes.getMasterUrl()); } CloseableHttpClient httpclient = HttpClients.createDefault(); CloseableHttpClient httpclientPost = HttpClients.createDefault(); String GERRIT_URL = gerritAddress + "/a/projects/" + repoName; HttpGet httpget = new HttpGet(GERRIT_URL); System.out.println("Requesting : " + httpget.getURI()); try { //Initial request without credentials returns "HTTP/1.1 401 Unauthorized" HttpResponse response = httpclient.execute(httpget); System.out.println(response.getStatusLine()); if (response.getStatusLine().getStatusCode() == HttpStatus.SC_UNAUTHORIZED) { // Get current current "WWW-Authenticate" header from response // WWW-Authenticate:Digest realm="My Test Realm", qop="auth", // nonce="cdcf6cbe6ee17ae0790ed399935997e8", opaque="ae40d7c8ca6a35af15460d352be5e71c" Header authHeader = response.getFirstHeader(AUTH.WWW_AUTH); System.out.println("authHeader = " + authHeader); DigestScheme digestScheme = new DigestScheme(); //Parse realm, nonce sent by server. digestScheme.processChallenge(authHeader); UsernamePasswordCredentials creds = new UsernamePasswordCredentials(gerritUser, gerritPwd); httpget.addHeader(digestScheme.authenticate(creds, httpget, null)); HttpPost httpPost = new HttpPost(GERRIT_URL); httpPost.addHeader(digestScheme.authenticate(creds, httpPost, null)); httpPost.addHeader("Content-Type", "application/json"); CreateRepositoryDTO createRepoDTO = new CreateRepositoryDTO(); createRepoDTO.setDescription(gerritGitRepoDescription); createRepoDTO.setName(repoName); createRepoDTO.setCreate_empty_commit(Boolean.valueOf(gerritGitInitialCommit)); ObjectMapper mapper = new ObjectMapper(); String json = mapper.writeValueAsString(createRepoDTO); HttpEntity entity = new StringEntity(json); httpPost.setEntity(entity); ResponseHandler<String> responseHandler = new BasicResponseHandler(); String responseBody = httpclientPost.execute(httpPost, responseHandler); System.out.println("responseBody : " + responseBody); } } catch (MalformedChallengeException e) { e.printStackTrace(); } catch (AuthenticationException e) { e.printStackTrace(); } catch (ConnectException e) { System.out.println("Gerrit Server is not responding"); } catch (HttpResponseException e) { System.out.println("Response from Gerrit Server : " + e.getMessage()); throw new Exception("Repository " + repoName + " already exists !"); } finally { httpclient.close(); httpclientPost.close(); } } @Priority(value = 1000) protected static class RemovePrefix implements ReaderInterceptor { @Override public Object aroundReadFrom(ReaderInterceptorContext interceptorContext) throws IOException, WebApplicationException { InputStream in = interceptorContext.getInputStream(); BufferedReader reader = new BufferedReader(new InputStreamReader(in)); StringBuilder received = new StringBuilder(); String line; while ((line = reader.readLine()) != null) { received.append(line); } String s = received.toString(); s = s.replace(JSON_MAGIC, ""); System.out.println("Reader Interceptor removing the prefix invoked."); System.out.println("Content cleaned : " + s); String responseContent = new String(s); interceptorContext.setInputStream(new ByteArrayInputStream(responseContent.getBytes())); return interceptorContext.proceed(); } } protected void createTaigaWebhook(TaigaClient taiga, ProjectDTO project) { if (taiga != null && project != null) { Long projectId = project.getId(); ModuleDTO module = taiga.moduleForProject(projectId, TaigaModule.GOGS); if (module != null) { String webhookSecret = module.getSecret(); String webhook = taiga.getPublicWebhookUrl(module); if (Strings.isNotBlank(webhookSecret) && Strings.isNotBlank(webhook)) { createWebhook(webhook, webhookSecret); } else { getLog().warn("Could not create webhook for Taiga. Missing module data for url: " + webhook + " secret: " + webhookSecret); } } else { getLog().warn("No module for gogs so cannot create Taiga webhook"); } } } protected boolean createWebhook(String url, String webhookSecret) { // TODO we should only register a webhook if either git + other system is on premise or if its all online // e.g. we shouldn't try to register webhooks on public github with on premise services try { GitRepoClient gitRepoClient = getGitRepoClient(); WebHooks.createGogsWebhook(gitRepoClient, getLog(), username, repoName, url, webhookSecret); return true; } catch (Exception e) { getLog().error("Failed to create webhook " + url + " on repository " + repoName + ". Reason: " + e, e); return false; } } }