| | |
| | | import javax.mail.MessagingException; |
| | | import javax.mail.internet.MimeBodyPart; |
| | | import javax.mail.internet.MimeMultipart; |
| | | import javax.naming.Context; |
| | | import javax.naming.InitialContext; |
| | | import javax.naming.NamingException; |
| | | import javax.servlet.ServletContext; |
| | | import javax.servlet.ServletContextEvent; |
| | | import javax.servlet.ServletContextListener; |
| | |
| | | |
| | | import com.gitblit.Constants.AccessPermission; |
| | | import com.gitblit.Constants.AccessRestrictionType; |
| | | import com.gitblit.Constants.AccountType; |
| | | import com.gitblit.Constants.AuthenticationType; |
| | | import com.gitblit.Constants.AuthorizationControl; |
| | | import com.gitblit.Constants.CommitMessageRenderer; |
| | | import com.gitblit.Constants.FederationRequest; |
| | | import com.gitblit.Constants.FederationStrategy; |
| | | import com.gitblit.Constants.FederationToken; |
| | |
| | | import com.gitblit.models.GitClientApplication; |
| | | import com.gitblit.models.Metric; |
| | | import com.gitblit.models.ProjectModel; |
| | | import com.gitblit.models.RefModel; |
| | | import com.gitblit.models.RegistrantAccessPermission; |
| | | import com.gitblit.models.RepositoryModel; |
| | | import com.gitblit.models.RepositoryUrl; |
| | |
| | | import com.gitblit.utils.ArrayUtils; |
| | | import com.gitblit.utils.Base64; |
| | | import com.gitblit.utils.ByteFormat; |
| | | import com.gitblit.utils.CommitCache; |
| | | import com.gitblit.utils.ContainerUtils; |
| | | import com.gitblit.utils.DeepCopier; |
| | | import com.gitblit.utils.FederationUtils; |
| | | import com.gitblit.utils.HttpUtils; |
| | | import com.gitblit.utils.JGitUtils; |
| | | import com.gitblit.utils.JGitUtils.LastChange; |
| | | import com.gitblit.utils.JsonUtils; |
| | | import com.gitblit.utils.MarkdownUtils; |
| | | import com.gitblit.utils.MetricUtils; |
| | | import com.gitblit.utils.ModelUtils; |
| | | import com.gitblit.utils.ObjectCache; |
| | | import com.gitblit.utils.StringUtils; |
| | | import com.gitblit.utils.TimeUtils; |
| | |
| | | * the web ui and the servlets. This class is either directly instantiated by |
| | | * the GitBlitServer class (Gitblit GO) or is reflectively instantiated from the |
| | | * definition in the web.xml file (Gitblit WAR). |
| | | * |
| | | * |
| | | * This class is the central logic processor for Gitblit. All settings, user |
| | | * object, and repository object operations pass through this class. |
| | | * |
| | | * |
| | | * Repository Resolution. There are two pathways for finding repositories. One |
| | | * pathway, for web ui display and repository authentication & authorization, is |
| | | * within this class. The other pathway is through the standard GitServlet. |
| | | * |
| | | * |
| | | * @author James Moger |
| | | * |
| | | * |
| | | */ |
| | | public class GitBlit implements ServletContextListener { |
| | | |
| | | private static GitBlit gitblit; |
| | | |
| | | |
| | | private final Logger logger = LoggerFactory.getLogger(GitBlit.class); |
| | | |
| | | private final ScheduledExecutorService scheduledExecutor = Executors.newScheduledThreadPool(5); |
| | | private final ScheduledExecutorService scheduledExecutor = Executors.newScheduledThreadPool(10); |
| | | |
| | | private final List<FederationModel> federationRegistrations = Collections |
| | | .synchronizedList(new ArrayList<FederationModel>()); |
| | | |
| | | |
| | | private final ObjectCache<Collection<GitClientApplication>> clientApplications = new ObjectCache<Collection<GitClientApplication>>(); |
| | | |
| | | private final Map<String, FederationModel> federationPullResults = new ConcurrentHashMap<String, FederationModel>(); |
| | |
| | | private final ObjectCache<Long> repositorySizeCache = new ObjectCache<Long>(); |
| | | |
| | | private final ObjectCache<List<Metric>> repositoryMetricsCache = new ObjectCache<List<Metric>>(); |
| | | |
| | | |
| | | private final Map<String, RepositoryModel> repositoryListCache = new ConcurrentHashMap<String, RepositoryModel>(); |
| | | |
| | | |
| | | private final Map<String, ProjectModel> projectCache = new ConcurrentHashMap<String, ProjectModel>(); |
| | | |
| | | |
| | | private final AtomicReference<String> repositoryListSettingsChecksum = new AtomicReference<String>(""); |
| | | |
| | | |
| | | private final ObjectCache<String> projectMarkdownCache = new ObjectCache<String>(); |
| | | |
| | | |
| | | private final ObjectCache<String> projectRepositoriesMarkdownCache = new ObjectCache<String>(); |
| | | |
| | | private ServletContext servletContext; |
| | | |
| | | |
| | | private File baseFolder; |
| | | |
| | | private File repositoriesFolder; |
| | |
| | | private ServerStatus serverStatus; |
| | | |
| | | private MailExecutor mailExecutor; |
| | | |
| | | |
| | | private LuceneExecutor luceneExecutor; |
| | | |
| | | |
| | | private GCExecutor gcExecutor; |
| | | |
| | | |
| | | private MirrorExecutor mirrorExecutor; |
| | | |
| | | private TimeZone timezone; |
| | | |
| | | |
| | | private FileBasedConfig projectConfigs; |
| | | |
| | | |
| | | private FanoutService fanoutService; |
| | | |
| | | private GitDaemon gitDaemon; |
| | |
| | | |
| | | /** |
| | | * Returns the Gitblit singleton. |
| | | * |
| | | * |
| | | * @return gitblit singleton |
| | | */ |
| | | public static GitBlit self() { |
| | |
| | | } |
| | | |
| | | /** |
| | | * Returns the boot date of the Gitblit server. |
| | | * |
| | | * @return the boot date of Gitblit |
| | | */ |
| | | public static Date getBootDate() { |
| | | return self().serverStatus.bootDate; |
| | | } |
| | | |
| | | /** |
| | | * Returns the most recent change date of any repository served by Gitblit. |
| | | * |
| | | * @return a date |
| | | */ |
| | | public static Date getLastActivityDate() { |
| | | Date date = null; |
| | | for (String name : self().getRepositoryList()) { |
| | | Repository r = self().getRepository(name); |
| | | Date lastChange = JGitUtils.getLastChange(r).when; |
| | | r.close(); |
| | | if (lastChange != null && (date == null || lastChange.after(date))) { |
| | | date = lastChange; |
| | | } |
| | | } |
| | | return date; |
| | | } |
| | | |
| | | /** |
| | | * Determine if this is the GO variant of Gitblit. |
| | | * |
| | | * |
| | | * @return true if this is the GO variant of Gitblit. |
| | | */ |
| | | public static boolean isGO() { |
| | | return self().settings instanceof FileSettings; |
| | | } |
| | | |
| | | |
| | | /** |
| | | * Determine if this Gitblit instance is actively serving git repositories |
| | | * or if it is merely a repository viewer. |
| | | * |
| | | * |
| | | * @return true if Gitblit is serving repositories |
| | | */ |
| | | public static boolean isServingRepositories() { |
| | |
| | | /** |
| | | * Determine if this Gitblit instance is actively serving git repositories |
| | | * or if it is merely a repository viewer. |
| | | * |
| | | * |
| | | * @return true if Gitblit is serving repositories |
| | | */ |
| | | public static boolean isSendingMail() { |
| | |
| | | |
| | | /** |
| | | * Returns the preferred timezone for the Gitblit instance. |
| | | * |
| | | * |
| | | * @return a timezone |
| | | */ |
| | | public static TimeZone getTimezone() { |
| | |
| | | } |
| | | return self().timezone; |
| | | } |
| | | |
| | | |
| | | /** |
| | | * Returns the active settings. |
| | | * |
| | | * @return the active settings |
| | | */ |
| | | public static IStoredSettings getSettings() { |
| | | return self().settings; |
| | | } |
| | | |
| | | /** |
| | | * Returns the user-defined blob encodings. |
| | | * |
| | | * |
| | | * @return an array of encodings, may be empty |
| | | */ |
| | | public static String [] getEncodings() { |
| | | return getStrings(Keys.web.blobEncodings).toArray(new String[0]); |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Returns the boolean value for the specified key. If the key does not |
| | | * exist or the value for the key can not be interpreted as a boolean, the |
| | | * defaultValue is returned. |
| | | * |
| | | * |
| | | * @see IStoredSettings.getBoolean(String, boolean) |
| | | * @param key |
| | | * @param defaultValue |
| | |
| | | * Returns the integer value for the specified key. If the key does not |
| | | * exist or the value for the key can not be interpreted as an integer, the |
| | | * defaultValue is returned. |
| | | * |
| | | * |
| | | * @see IStoredSettings.getInteger(String key, int defaultValue) |
| | | * @param key |
| | | * @param defaultValue |
| | |
| | | * Returns the integer list for the specified key. If the key does not |
| | | * exist or the value for the key can not be interpreted as an integer, an |
| | | * empty list is returned. |
| | | * |
| | | * |
| | | * @see IStoredSettings.getIntegers(String key) |
| | | * @param key |
| | | * @return key value or defaultValue |
| | |
| | | public static List<Integer> getIntegers(String key) { |
| | | return self().settings.getIntegers(key); |
| | | } |
| | | |
| | | |
| | | /** |
| | | * Returns the value in bytes for the specified key. If the key does not |
| | | * exist or the value for the key can not be interpreted as an integer, the |
| | | * defaultValue is returned. |
| | | * |
| | | * |
| | | * @see IStoredSettings.getFilesize(String key, int defaultValue) |
| | | * @param key |
| | | * @param defaultValue |
| | |
| | | * Returns the value in bytes for the specified key. If the key does not |
| | | * exist or the value for the key can not be interpreted as a long, the |
| | | * defaultValue is returned. |
| | | * |
| | | * |
| | | * @see IStoredSettings.getFilesize(String key, long defaultValue) |
| | | * @param key |
| | | * @param defaultValue |
| | |
| | | * Returns the char value for the specified key. If the key does not exist |
| | | * or the value for the key can not be interpreted as a character, the |
| | | * defaultValue is returned. |
| | | * |
| | | * |
| | | * @see IStoredSettings.getChar(String key, char defaultValue) |
| | | * @param key |
| | | * @param defaultValue |
| | |
| | | * Returns the string value for the specified key. If the key does not exist |
| | | * or the value for the key can not be interpreted as a string, the |
| | | * defaultValue is returned. |
| | | * |
| | | * |
| | | * @see IStoredSettings.getString(String key, String defaultValue) |
| | | * @param key |
| | | * @param defaultValue |
| | |
| | | |
| | | /** |
| | | * Returns a list of space-separated strings from the specified key. |
| | | * |
| | | * |
| | | * @see IStoredSettings.getStrings(String key) |
| | | * @param n |
| | | * @return list of strings |
| | |
| | | |
| | | /** |
| | | * Returns a map of space-separated key-value pairs from the specified key. |
| | | * |
| | | * |
| | | * @see IStoredSettings.getStrings(String key) |
| | | * @param n |
| | | * @return map of string, string |
| | |
| | | /** |
| | | * Returns the list of keys whose name starts with the specified prefix. If |
| | | * the prefix is null or empty, all key names are returned. |
| | | * |
| | | * |
| | | * @see IStoredSettings.getAllKeys(String key) |
| | | * @param startingWith |
| | | * @return list of keys |
| | |
| | | |
| | | /** |
| | | * Is Gitblit running in debug mode? |
| | | * |
| | | * |
| | | * @return true if Gitblit is running in debug mode |
| | | */ |
| | | public static boolean isDebugMode() { |
| | |
| | | |
| | | /** |
| | | * Returns the file object for the specified configuration key. |
| | | * |
| | | * |
| | | * @return the file |
| | | */ |
| | | public static File getFileOrFolder(String key, String defaultFileOrFolder) { |
| | |
| | | * file or folder retrievals are (at least initially) funneled through this |
| | | * method so it is the correct point to globally override/alter filesystem |
| | | * access based on environment or some other indicator. |
| | | * |
| | | * |
| | | * @return the file |
| | | */ |
| | | public static File getFileOrFolder(String fileOrFolder) { |
| | |
| | | /** |
| | | * Returns the path of the repositories folder. This method checks to see if |
| | | * Gitblit is running on a cloud service and may return an adjusted path. |
| | | * |
| | | * |
| | | * @return the repositories folder path |
| | | */ |
| | | public static File getRepositoriesFolder() { |
| | |
| | | /** |
| | | * Returns the path of the proposals folder. This method checks to see if |
| | | * Gitblit is running on a cloud service and may return an adjusted path. |
| | | * |
| | | * |
| | | * @return the proposals folder path |
| | | */ |
| | | public static File getProposalsFolder() { |
| | |
| | | /** |
| | | * Returns the path of the Groovy folder. This method checks to see if |
| | | * Gitblit is running on a cloud service and may return an adjusted path. |
| | | * |
| | | * |
| | | * @return the Groovy scripts folder path |
| | | */ |
| | | public static File getGroovyScriptsFolder() { |
| | | return getFileOrFolder(Keys.groovy.scriptsFolder, "${baseFolder}/groovy"); |
| | | } |
| | | |
| | | |
| | | /** |
| | | * Updates the list of server settings. |
| | | * |
| | | * |
| | | * @param settings |
| | | * @return true if the update succeeded |
| | | */ |
| | |
| | | serverStatus.heapFree = Runtime.getRuntime().freeMemory(); |
| | | return serverStatus; |
| | | } |
| | | |
| | | |
| | | /** |
| | | * Returns a list of repository URLs and the user access permission. |
| | | * |
| | | * |
| | | * @param request |
| | | * @param user |
| | | * @param repository |
| | |
| | | if (user == null) { |
| | | user = UserModel.ANONYMOUS; |
| | | } |
| | | String username = UserModel.ANONYMOUS.equals(user) ? "" : user.username; |
| | | String username = encodeUsername(UserModel.ANONYMOUS.equals(user) ? "" : user.username); |
| | | |
| | | List<RepositoryUrl> list = new ArrayList<RepositoryUrl>(); |
| | | // http/https url |
| | |
| | | } |
| | | return list; |
| | | } |
| | | |
| | | |
| | | protected String getRepositoryUrl(HttpServletRequest request, String username, RepositoryModel repository) { |
| | | StringBuilder sb = new StringBuilder(); |
| | | sb.append(HttpUtils.getGitblitURL(request)); |
| | | sb.append(Constants.GIT_PATH); |
| | | sb.append(repository.name); |
| | | |
| | | |
| | | // inject username into repository url if authentication is required |
| | | if (repository.accessRestriction.exceeds(AccessRestrictionType.NONE) |
| | | && !StringUtils.isEmpty(username)) { |
| | |
| | | } |
| | | return sb.toString(); |
| | | } |
| | | |
| | | |
| | | protected String getGitDaemonUrl(HttpServletRequest request, UserModel user, RepositoryModel repository) { |
| | | if (gitDaemon != null) { |
| | | String bindInterface = settings.getString(Keys.git.daemonBindInterface, "localhost"); |
| | |
| | | } |
| | | return null; |
| | | } |
| | | |
| | | |
| | | protected AccessPermission getGitDaemonAccessPermission(UserModel user, RepositoryModel repository) { |
| | | if (gitDaemon != null && user.canClone(repository)) { |
| | | AccessPermission gitDaemonPermission = user.getRepositoryPermission(repository).permission; |
| | |
| | | /** |
| | | * Returns the list of custom client applications to be used for the |
| | | * repository url panel; |
| | | * |
| | | * |
| | | * @return a collection of client applications |
| | | */ |
| | | public Collection<GitClientApplication> getClientApplications() { |
| | |
| | | if (clients != null) { |
| | | clientApplications.updateObject("user", lastModified, clients); |
| | | return clients; |
| | | } |
| | | } |
| | | } catch (IOException e) { |
| | | logger.error("Failed to deserialize " + userDefs.getAbsolutePath(), e); |
| | | } |
| | | } |
| | | } |
| | | |
| | | |
| | | // no user definitions, use system definitions |
| | | if (!clientApplications.hasCurrent("system", new Date(0))) { |
| | | try { |
| | |
| | | logger.error("Failed to deserialize clientapps.json resource!", e); |
| | | } |
| | | } |
| | | |
| | | |
| | | return clientApplications.getObject("system"); |
| | | } |
| | | |
| | | |
| | | private Collection<GitClientApplication> readClientApplications(InputStream is) { |
| | | try { |
| | | Type type = new TypeToken<Collection<GitClientApplication>>() { |
| | |
| | | /** |
| | | * Set the user service. The user service authenticates all users and is |
| | | * responsible for managing user permissions. |
| | | * |
| | | * |
| | | * @param userService |
| | | */ |
| | | public void setUserService(IUserService userService) { |
| | |
| | | this.userService = userService; |
| | | this.userService.setup(settings); |
| | | } |
| | | |
| | | |
| | | public boolean supportsAddUser() { |
| | | return supportsCredentialChanges(new UserModel("")); |
| | | } |
| | | |
| | | |
| | | /** |
| | | * Returns true if the user's credentials can be changed. |
| | | * |
| | | * |
| | | * @param user |
| | | * @return true if the user service supports credential changes |
| | | */ |
| | | public boolean supportsCredentialChanges(UserModel user) { |
| | | return (user != null && user.isLocalAccount()) || userService.supportsCredentialChanges(); |
| | | if (user == null) { |
| | | return false; |
| | | } else if (AccountType.LOCAL.equals(user.accountType)) { |
| | | // local account, we can change credentials |
| | | return true; |
| | | } else { |
| | | // external account, ask user service |
| | | return userService.supportsCredentialChanges(); |
| | | } |
| | | } |
| | | |
| | | /** |
| | | * Returns true if the user's display name can be changed. |
| | | * |
| | | * |
| | | * @param user |
| | | * @return true if the user service supports display name changes |
| | | */ |
| | |
| | | |
| | | /** |
| | | * Returns true if the user's email address can be changed. |
| | | * |
| | | * |
| | | * @param user |
| | | * @return true if the user service supports email address changes |
| | | */ |
| | |
| | | |
| | | /** |
| | | * Returns true if the user's team memberships can be changed. |
| | | * |
| | | * |
| | | * @param user |
| | | * @return true if the user service supports team membership changes |
| | | */ |
| | |
| | | } |
| | | |
| | | /** |
| | | * Returns true if the username represents an internal account |
| | | * |
| | | * @param username |
| | | * @return true if the specified username represents an internal account |
| | | */ |
| | | protected boolean isInternalAccount(String username) { |
| | | return !StringUtils.isEmpty(username) |
| | | && (username.equalsIgnoreCase(Constants.FEDERATION_USER) |
| | | || username.equalsIgnoreCase(UserModel.ANONYMOUS.username)); |
| | | } |
| | | |
| | | /** |
| | | * Authenticate a user based on a username and password. |
| | | * |
| | | * |
| | | * @see IUserService.authenticate(String, char[]) |
| | | * @param username |
| | | * @param password |
| | |
| | | // can not authenticate empty username |
| | | return null; |
| | | } |
| | | String usernameDecoded = decodeUsername(username); |
| | | String pw = new String(password); |
| | | if (StringUtils.isEmpty(pw)) { |
| | | // can not authenticate empty password |
| | |
| | | |
| | | // check to see if this is the federation user |
| | | if (canFederate()) { |
| | | if (username.equalsIgnoreCase(Constants.FEDERATION_USER)) { |
| | | if (usernameDecoded.equalsIgnoreCase(Constants.FEDERATION_USER)) { |
| | | List<String> tokens = getFederationTokens(); |
| | | if (tokens.contains(pw)) { |
| | | // the federation user is an administrator |
| | | UserModel federationUser = new UserModel(Constants.FEDERATION_USER); |
| | | federationUser.canAdmin = true; |
| | | return federationUser; |
| | | return getFederationUser(); |
| | | } |
| | | } |
| | | } |
| | |
| | | if (userService == null) { |
| | | return null; |
| | | } |
| | | return userService.authenticate(username, password); |
| | | return userService.authenticate(usernameDecoded, password); |
| | | } |
| | | |
| | | /** |
| | | * Authenticate a user based on their cookie. |
| | | * |
| | | * |
| | | * @param cookies |
| | | * @return a user object or null |
| | | */ |
| | |
| | | |
| | | /** |
| | | * Authenticate a user based on HTTP request parameters. |
| | | * |
| | | * |
| | | * Authentication by X509Certificate is tried first and then by cookie. |
| | | * |
| | | * |
| | | * @param httpRequest |
| | | * @return a user object or null |
| | | */ |
| | | public UserModel authenticate(HttpServletRequest httpRequest) { |
| | | return authenticate(httpRequest, false); |
| | | } |
| | | |
| | | |
| | | /** |
| | | * Authenticate a user based on HTTP request parameters. |
| | | * |
| | | * |
| | | * Authentication by X509Certificate, servlet container principal, cookie, |
| | | * and BASIC header. |
| | | * |
| | | * |
| | | * @param httpRequest |
| | | * @param requiresCertificate |
| | | * @return a user object or null |
| | |
| | | model.username, metadata.serialNumber, httpRequest.getRemoteAddr())); |
| | | } |
| | | } |
| | | |
| | | |
| | | if (requiresCertificate) { |
| | | // caller requires client certificate authentication (e.g. git servlet) |
| | | return null; |
| | | } |
| | | |
| | | |
| | | // try to authenticate by servlet container principal |
| | | Principal principal = httpRequest.getUserPrincipal(); |
| | | if (principal != null) { |
| | | String username = principal.getName(); |
| | | if (!StringUtils.isEmpty(username)) { |
| | | boolean internalAccount = isInternalAccount(username); |
| | | UserModel user = getUserModel(username); |
| | | if (user != null) { |
| | | // existing user |
| | |
| | | logger.debug(MessageFormat.format("{0} authenticated by servlet container principal from {1}", |
| | | user.username, httpRequest.getRemoteAddr())); |
| | | return user; |
| | | } else if (settings.getBoolean(Keys.realm.container.autoCreateAccounts, true)) { |
| | | } else if (settings.getBoolean(Keys.realm.container.autoCreateAccounts, false) |
| | | && !internalAccount) { |
| | | // auto-create user from an authenticated container principal |
| | | user = new UserModel(username.toLowerCase()); |
| | | user.displayName = username; |
| | |
| | | logger.debug(MessageFormat.format("{0} authenticated and created by servlet container principal from {1}", |
| | | user.username, httpRequest.getRemoteAddr())); |
| | | return user; |
| | | } else { |
| | | } else if (!internalAccount) { |
| | | logger.warn(MessageFormat.format("Failed to find UserModel for {0}, attempted servlet container authentication from {1}", |
| | | principal.getName(), httpRequest.getRemoteAddr())); |
| | | } |
| | | } |
| | | } |
| | | |
| | | |
| | | // try to authenticate by cookie |
| | | if (allowCookieAuthentication()) { |
| | | UserModel user = authenticate(httpRequest.getCookies()); |
| | |
| | | return user; |
| | | } |
| | | } |
| | | |
| | | |
| | | // try to authenticate by BASIC |
| | | final String authorization = httpRequest.getHeader("Authorization"); |
| | | if (authorization != null && authorization.startsWith("Basic")) { |
| | |
| | | user.username, httpRequest.getRemoteAddr())); |
| | | return user; |
| | | } else { |
| | | logger.warn(MessageFormat.format("Failed login attempt for {0}, invalid credentials ({1}) from {2}", |
| | | username, credentials, httpRequest.getRemoteAddr())); |
| | | logger.warn(MessageFormat.format("Failed login attempt for {0}, invalid credentials from {1}", |
| | | username, httpRequest.getRemoteAddr())); |
| | | } |
| | | } |
| | | } |
| | | return null; |
| | | } |
| | | |
| | | |
| | | protected void flagWicketSession(AuthenticationType authenticationType) { |
| | | RequestCycle requestCycle = RequestCycle.get(); |
| | | if (requestCycle != null) { |
| | |
| | | |
| | | /** |
| | | * Sets a cookie for the specified user. |
| | | * |
| | | * |
| | | * @param response |
| | | * @param user |
| | | */ |
| | |
| | | if (userService == null) { |
| | | return; |
| | | } |
| | | if (userService.supportsCookies()) { |
| | | GitBlitWebSession session = GitBlitWebSession.get(); |
| | | boolean standardLogin = session.authenticationType.isStandard(); |
| | | |
| | | if (userService.supportsCookies() && standardLogin) { |
| | | Cookie userCookie; |
| | | if (user == null) { |
| | | // clear cookie for logout |
| | |
| | | response.addCookie(userCookie); |
| | | } |
| | | } |
| | | |
| | | |
| | | /** |
| | | * Logout a user. |
| | | * |
| | | * |
| | | * @param user |
| | | */ |
| | | public void logout(UserModel user) { |
| | |
| | | } |
| | | |
| | | /** |
| | | * Encode the username for user in an url. |
| | | * |
| | | * @param name |
| | | * @return the encoded name |
| | | */ |
| | | protected String encodeUsername(String name) { |
| | | return name.replace("@", "%40").replace(" ", "%20").replace("\\", "%5C"); |
| | | } |
| | | |
| | | /** |
| | | * Decode a username from an encoded url. |
| | | * |
| | | * @param name |
| | | * @return the decoded name |
| | | */ |
| | | protected String decodeUsername(String name) { |
| | | return name.replace("%40", "@").replace("%20", " ").replace("%5C", "\\"); |
| | | } |
| | | |
| | | /** |
| | | * Returns the list of all users available to the login service. |
| | | * |
| | | * |
| | | * @see IUserService.getAllUsernames() |
| | | * @return list of all usernames |
| | | */ |
| | |
| | | |
| | | /** |
| | | * Returns the list of all users available to the login service. |
| | | * |
| | | * |
| | | * @see IUserService.getAllUsernames() |
| | | * @return list of all usernames |
| | | */ |
| | |
| | | |
| | | /** |
| | | * Delete the user object with the specified username |
| | | * |
| | | * |
| | | * @see IUserService.deleteUser(String) |
| | | * @param username |
| | | * @return true if successful |
| | |
| | | if (StringUtils.isEmpty(username)) { |
| | | return false; |
| | | } |
| | | return userService.deleteUser(username); |
| | | String usernameDecoded = decodeUsername(username); |
| | | return userService.deleteUser(usernameDecoded); |
| | | } |
| | | |
| | | protected UserModel getFederationUser() { |
| | | // the federation user is an administrator |
| | | UserModel federationUser = new UserModel(Constants.FEDERATION_USER); |
| | | federationUser.canAdmin = true; |
| | | return federationUser; |
| | | } |
| | | |
| | | /** |
| | | * Retrieve the user object for the specified username. |
| | | * |
| | | * |
| | | * @see IUserService.getUserModel(String) |
| | | * @param username |
| | | * @return a user object or null |
| | |
| | | if (StringUtils.isEmpty(username)) { |
| | | return null; |
| | | } |
| | | UserModel user = userService.getUserModel(username); |
| | | String usernameDecoded = decodeUsername(username); |
| | | UserModel user = userService.getUserModel(usernameDecoded); |
| | | return user; |
| | | } |
| | | |
| | | |
| | | /** |
| | | * Returns the effective list of permissions for this user, taking into account |
| | | * team memberships, ownerships. |
| | | * |
| | | * |
| | | * @param user |
| | | * @return the effective list of permissions for the user |
| | | */ |
| | |
| | | set.add(rp); |
| | | } |
| | | } |
| | | |
| | | |
| | | List<RegistrantAccessPermission> list = new ArrayList<RegistrantAccessPermission>(set); |
| | | Collections.sort(list); |
| | | return list; |
| | |
| | | * Returns the list of users and their access permissions for the specified |
| | | * repository including permission source information such as the team or |
| | | * regular expression which sets the permission. |
| | | * |
| | | * |
| | | * @param repository |
| | | * @return a list of RegistrantAccessPermissions |
| | | */ |
| | |
| | | } |
| | | return list; |
| | | } |
| | | |
| | | |
| | | /** |
| | | * Sets the access permissions to the specified repository for the specified users. |
| | | * |
| | | * |
| | | * @param repository |
| | | * @param permissions |
| | | * @return true if the user models have been updated |
| | |
| | | } |
| | | return userService.updateUserModels(users); |
| | | } |
| | | |
| | | |
| | | /** |
| | | * Returns the list of all users who have an explicit access permission |
| | | * for the specified repository. |
| | | * |
| | | * |
| | | * @see IUserService.getUsernamesForRepositoryRole(String) |
| | | * @param repository |
| | | * @return list of all usernames that have an access permission for the repository |
| | |
| | | /** |
| | | * Sets the list of all uses who are allowed to bypass the access |
| | | * restriction placed on the specified repository. |
| | | * |
| | | * |
| | | * @see IUserService.setUsernamesForRepositoryRole(String, List<String>) |
| | | * @param repository |
| | | * @param usernames |
| | |
| | | /** |
| | | * Adds/updates a complete user object keyed by username. This method allows |
| | | * for renaming a user. |
| | | * |
| | | * |
| | | * @see IUserService.updateUserModel(String, UserModel) |
| | | * @param username |
| | | * @param user |
| | |
| | | "Failed to rename ''{0}'' because ''{1}'' already exists.", username, |
| | | user.username)); |
| | | } |
| | | |
| | | |
| | | // rename repositories and owner fields for all repositories |
| | | for (RepositoryModel model : getRepositoryModels(user)) { |
| | | if (model.isUsersPersonalRepository(username)) { |
| | | // personal repository |
| | | model.addOwner(user.username); |
| | | String oldRepositoryName = model.name; |
| | | model.name = "~" + user.username + model.name.substring(model.projectPath.length()); |
| | | model.projectPath = "~" + user.username; |
| | | model.name = user.getPersonalPath() + model.name.substring(model.projectPath.length()); |
| | | model.projectPath = user.getPersonalPath(); |
| | | updateRepositoryModel(oldRepositoryName, model, false); |
| | | } else if (model.isOwner(username)) { |
| | | // common/shared repo |
| | |
| | | /** |
| | | * Returns the list of available teams that a user or repository may be |
| | | * assigned to. |
| | | * |
| | | * |
| | | * @return the list of teams |
| | | */ |
| | | public List<String> getAllTeamnames() { |
| | |
| | | /** |
| | | * Returns the list of available teams that a user or repository may be |
| | | * assigned to. |
| | | * |
| | | * |
| | | * @return the list of teams |
| | | */ |
| | | public List<TeamModel> getAllTeams() { |
| | |
| | | |
| | | /** |
| | | * Returns the TeamModel object for the specified name. |
| | | * |
| | | * |
| | | * @param teamname |
| | | * @return a TeamModel object or null |
| | | */ |
| | | public TeamModel getTeamModel(String teamname) { |
| | | return userService.getTeamModel(teamname); |
| | | } |
| | | |
| | | |
| | | /** |
| | | * Returns the list of teams and their access permissions for the specified |
| | | * repository including the source of the permission such as the admin flag |
| | | * or a regular expression. |
| | | * |
| | | * |
| | | * @param repository |
| | | * @return a list of RegistrantAccessPermissions |
| | | */ |
| | |
| | | Collections.sort(list); |
| | | return list; |
| | | } |
| | | |
| | | |
| | | /** |
| | | * Sets the access permissions to the specified repository for the specified teams. |
| | | * |
| | | * |
| | | * @param repository |
| | | * @param permissions |
| | | * @return true if the team models have been updated |
| | |
| | | } |
| | | return userService.updateTeamModels(teams); |
| | | } |
| | | |
| | | |
| | | /** |
| | | * Returns the list of all teams who have an explicit access permission for |
| | | * the specified repository. |
| | | * |
| | | * |
| | | * @see IUserService.getTeamnamesForRepositoryRole(String) |
| | | * @param repository |
| | | * @return list of all teamnames with explicit access permissions to the repository |
| | |
| | | /** |
| | | * Sets the list of all uses who are allowed to bypass the access |
| | | * restriction placed on the specified repository. |
| | | * |
| | | * |
| | | * @see IUserService.setTeamnamesForRepositoryRole(String, List<String>) |
| | | * @param repository |
| | | * @param teamnames |
| | |
| | | |
| | | /** |
| | | * Updates the TeamModel object for the specified name. |
| | | * |
| | | * |
| | | * @param teamname |
| | | * @param team |
| | | * @param isCreate |
| | |
| | | |
| | | /** |
| | | * Delete the team object with the specified teamname |
| | | * |
| | | * |
| | | * @see IUserService.deleteTeam(String) |
| | | * @param teamname |
| | | * @return true if successful |
| | |
| | | public boolean deleteTeam(String teamname) { |
| | | return userService.deleteTeam(teamname); |
| | | } |
| | | |
| | | |
| | | /** |
| | | * Adds the repository to the list of cached repositories if Gitblit is |
| | | * configured to cache the repository list. |
| | | * |
| | | * |
| | | * @param model |
| | | */ |
| | | private void addToCachedRepositoryList(RepositoryModel model) { |
| | | if (settings.getBoolean(Keys.git.cacheRepositoryList, true)) { |
| | | repositoryListCache.put(model.name.toLowerCase(), model); |
| | | |
| | | |
| | | // update the fork origin repository with this repository clone |
| | | if (!StringUtils.isEmpty(model.originRepository)) { |
| | | if (repositoryListCache.containsKey(model.originRepository)) { |
| | |
| | | } |
| | | } |
| | | } |
| | | |
| | | |
| | | /** |
| | | * Removes the repository from the list of cached repositories. |
| | | * |
| | | * |
| | | * @param name |
| | | * @return the model being removed |
| | | */ |
| | |
| | | |
| | | /** |
| | | * Clears all the cached metadata for the specified repository. |
| | | * |
| | | * |
| | | * @param repositoryName |
| | | */ |
| | | private void clearRepositoryMetadataCache(String repositoryName) { |
| | | repositorySizeCache.remove(repositoryName); |
| | | repositoryMetricsCache.remove(repositoryName); |
| | | } |
| | | |
| | | |
| | | /** |
| | | * Resets the repository list cache. |
| | | * |
| | | * |
| | | */ |
| | | public void resetRepositoryListCache() { |
| | | logger.info("Repository cache manually reset"); |
| | | repositoryListCache.clear(); |
| | | } |
| | | |
| | | |
| | | /** |
| | | * Calculate the checksum of settings that affect the repository list cache. |
| | | * @return a checksum |
| | |
| | | String checksum = StringUtils.getSHA1(ns.toString()); |
| | | return checksum; |
| | | } |
| | | |
| | | |
| | | /** |
| | | * Compare the last repository list setting checksum to the current checksum. |
| | | * If different then clear the cache so that it may be rebuilt. |
| | | * |
| | | * |
| | | * @return true if the cached repository list is valid since the last check |
| | | */ |
| | | private boolean isValidRepositoryList() { |
| | |
| | | /** |
| | | * Returns the list of all repositories available to Gitblit. This method |
| | | * does not consider user access permissions. |
| | | * |
| | | * |
| | | * @return list of all repositories |
| | | */ |
| | | public List<String> getRepositoryList() { |
| | | if (repositoryListCache.size() == 0 || !isValidRepositoryList()) { |
| | | // we are not caching OR we have not yet cached OR the cached list is invalid |
| | | long startTime = System.currentTimeMillis(); |
| | | List<String> repositories = JGitUtils.getRepositoryList(repositoriesFolder, |
| | | List<String> repositories = JGitUtils.getRepositoryList(repositoriesFolder, |
| | | settings.getBoolean(Keys.git.onlyAccessBareRepositories, false), |
| | | settings.getBoolean(Keys.git.searchRepositoriesSubfolders, true), |
| | | settings.getInteger(Keys.git.searchRecursionDepth, -1), |
| | |
| | | } else { |
| | | // we are caching this list |
| | | String msg = "{0} repositories identified in {1} msecs"; |
| | | |
| | | // optionally (re)calculate repository sizes |
| | | if (getBoolean(Keys.web.showRepositorySizes, true)) { |
| | | ByteFormat byteFormat = new ByteFormat(); |
| | | // optionally (re)calculate repository sizes |
| | | msg = "{0} repositories identified with calculated folder sizes in {1} msecs"; |
| | | for (String repository : repositories) { |
| | | RepositoryModel model = getRepositoryModel(repository); |
| | | if (!model.skipSizeCalculation) { |
| | | model.size = byteFormat.format(calculateSize(model)); |
| | | } |
| | | } |
| | | } else { |
| | | // update cache |
| | | for (String repository : repositories) { |
| | | getRepositoryModel(repository); |
| | | } |
| | | } |
| | | |
| | | |
| | | for (String repository : repositories) { |
| | | getRepositoryModel(repository); |
| | | } |
| | | |
| | | // rebuild fork networks |
| | | for (RepositoryModel model : repositoryListCache.values()) { |
| | | if (!StringUtils.isEmpty(model.originRepository)) { |
| | |
| | | } |
| | | } |
| | | } |
| | | |
| | | |
| | | long duration = System.currentTimeMillis() - startTime; |
| | | logger.info(MessageFormat.format(msg, repositoryListCache.size(), duration)); |
| | | } |
| | | } |
| | | |
| | | |
| | | // return sorted copy of cached list |
| | | List<String> list = new ArrayList<String>(repositoryListCache.keySet()); |
| | | List<String> list = new ArrayList<String>(); |
| | | for (RepositoryModel model : repositoryListCache.values()) { |
| | | list.add(model.name); |
| | | } |
| | | StringUtils.sortRepositorynames(list); |
| | | return list; |
| | | } |
| | | |
| | | /** |
| | | * Returns the JGit repository for the specified name. |
| | | * |
| | | * |
| | | * @param repositoryName |
| | | * @return repository or null |
| | | */ |
| | |
| | | |
| | | /** |
| | | * Returns the JGit repository for the specified name. |
| | | * |
| | | * |
| | | * @param repositoryName |
| | | * @param logError |
| | | * @return repository or null |
| | | */ |
| | | public Repository getRepository(String repositoryName, boolean logError) { |
| | | // Decode url-encoded repository name (issue-278) |
| | | // http://stackoverflow.com/questions/17183110 |
| | | repositoryName = repositoryName.replace("%7E", "~").replace("%7e", "~"); |
| | | |
| | | if (isCollectingGarbage(repositoryName)) { |
| | | logger.warn(MessageFormat.format("Rejecting request for {0}, busy collecting garbage!", repositoryName)); |
| | | return null; |
| | |
| | | File dir = FileKey.resolve(new File(repositoriesFolder, repositoryName), FS.DETECTED); |
| | | if (dir == null) |
| | | return null; |
| | | |
| | | |
| | | Repository r = null; |
| | | try { |
| | | FileKey key = FileKey.exact(dir, FS.DETECTED); |
| | |
| | | |
| | | /** |
| | | * Returns the list of repository models that are accessible to the user. |
| | | * |
| | | * |
| | | * @param user |
| | | * @return list of repository models accessible to user |
| | | */ |
| | |
| | | } |
| | | } |
| | | } |
| | | if (getBoolean(Keys.web.showRepositorySizes, true)) { |
| | | int repoCount = 0; |
| | | long startTime = System.currentTimeMillis(); |
| | | ByteFormat byteFormat = new ByteFormat(); |
| | | for (RepositoryModel model : repositories) { |
| | | if (!model.skipSizeCalculation) { |
| | | repoCount++; |
| | | model.size = byteFormat.format(calculateSize(model)); |
| | | } |
| | | } |
| | | long duration = System.currentTimeMillis() - startTime; |
| | | if (duration > 250) { |
| | | // only log calcualtion time if > 250 msecs |
| | | logger.info(MessageFormat.format("{0} repository sizes calculated in {1} msecs", |
| | | repoCount, duration)); |
| | | } |
| | | } |
| | | long duration = System.currentTimeMillis() - methodStart; |
| | | logger.info(MessageFormat.format("{0} repository models loaded for {1} in {2} msecs", |
| | | repositories.size(), user == null ? "anonymous" : user.username, duration)); |
| | |
| | | /** |
| | | * Returns a repository model if the repository exists and the user may |
| | | * access the repository. |
| | | * |
| | | * |
| | | * @param user |
| | | * @param repositoryName |
| | | * @return repository model or null |
| | |
| | | /** |
| | | * Returns the repository model for the specified repository. This method |
| | | * does not consider user access permissions. |
| | | * |
| | | * |
| | | * @param repositoryName |
| | | * @return repository model or null |
| | | */ |
| | | public RepositoryModel getRepositoryModel(String repositoryName) { |
| | | // Decode url-encoded repository name (issue-278) |
| | | // http://stackoverflow.com/questions/17183110 |
| | | repositoryName = repositoryName.replace("%7E", "~").replace("%7e", "~"); |
| | | |
| | | if (!repositoryListCache.containsKey(repositoryName)) { |
| | | RepositoryModel model = loadRepositoryModel(repositoryName); |
| | | if (model == null) { |
| | | return null; |
| | | } |
| | | addToCachedRepositoryList(model); |
| | | return model; |
| | | return DeepCopier.copy(model); |
| | | } |
| | | |
| | | |
| | | // cached model |
| | | RepositoryModel model = repositoryListCache.get(repositoryName.toLowerCase()); |
| | | |
| | |
| | | logger.error(MessageFormat.format("Repository \"{0}\" is missing! Removing from cache.", repositoryName)); |
| | | return null; |
| | | } |
| | | |
| | | |
| | | FileBasedConfig config = (FileBasedConfig) getRepositoryConfig(r); |
| | | if (config.isOutdated()) { |
| | | // reload model |
| | |
| | | removeFromCachedRepositoryList(model.name); |
| | | addToCachedRepositoryList(model); |
| | | } else { |
| | | // update a few repository parameters |
| | | // update a few repository parameters |
| | | if (!model.hasCommits) { |
| | | // update hasCommits, assume a repository only gains commits :) |
| | | model.hasCommits = JGitUtils.hasCommits(r); |
| | | } |
| | | |
| | | model.lastChange = JGitUtils.getLastChange(r); |
| | | if (!model.skipSizeCalculation) { |
| | | ByteFormat byteFormat = new ByteFormat(); |
| | | model.size = byteFormat.format(calculateSize(model)); |
| | | } |
| | | updateLastChangeFields(r, model); |
| | | } |
| | | r.close(); |
| | | |
| | | |
| | | // return a copy of the cached model |
| | | return DeepCopier.copy(model); |
| | | } |
| | | |
| | | |
| | | /** |
| | | * Returns the star count of the repository. |
| | | * |
| | | * |
| | | * @param repository |
| | | * @return the star count |
| | | */ |
| | |
| | | } |
| | | return count; |
| | | } |
| | | |
| | | |
| | | |
| | | private void reloadProjectMarkdown(ProjectModel project) { |
| | | // project markdown |
| | | File pmkd = new File(getRepositoriesFolder(), (project.isRoot ? "" : project.name) + "/project.mkd"); |
| | | if (pmkd.exists()) { |
| | | Date lm = new Date(pmkd.lastModified()); |
| | | if (!projectMarkdownCache.hasCurrent(project.name, lm)) { |
| | | String mkd = com.gitblit.utils.FileUtils.readContent(pmkd, "\n"); |
| | | projectMarkdownCache.updateObject(project.name, lm, mkd); |
| | | } |
| | | project.projectMarkdown = projectMarkdownCache.getObject(project.name); |
| | | } |
| | | |
| | | // project repositories markdown |
| | | File rmkd = new File(getRepositoriesFolder(), (project.isRoot ? "" : project.name) + "/repositories.mkd"); |
| | | if (rmkd.exists()) { |
| | | Date lm = new Date(rmkd.lastModified()); |
| | | if (!projectRepositoriesMarkdownCache.hasCurrent(project.name, lm)) { |
| | | String mkd = com.gitblit.utils.FileUtils.readContent(rmkd, "\n"); |
| | | projectRepositoriesMarkdownCache.updateObject(project.name, lm, mkd); |
| | | } |
| | | project.repositoriesMarkdown = projectRepositoriesMarkdownCache.getObject(project.name); |
| | | } |
| | | } |
| | | |
| | | |
| | | /** |
| | | * Returns the map of project config. This map is cached and reloaded if |
| | | * the underlying projects.conf file changes. |
| | | * |
| | | * |
| | | * @return project config map |
| | | */ |
| | | private Map<String, ProjectModel> getProjectConfigs() { |
| | | if (projectCache.isEmpty() || projectConfigs.isOutdated()) { |
| | | |
| | | |
| | | try { |
| | | projectConfigs.load(); |
| | | } catch (Exception e) { |
| | |
| | | } |
| | | project.title = projectConfigs.getString("project", name, "title"); |
| | | project.description = projectConfigs.getString("project", name, "description"); |
| | | |
| | | // project markdown |
| | | File pmkd = new File(getRepositoriesFolder(), (project.isRoot ? "" : name) + "/project.mkd"); |
| | | if (pmkd.exists()) { |
| | | Date lm = new Date(pmkd.lastModified()); |
| | | if (!projectMarkdownCache.hasCurrent(name, lm)) { |
| | | String mkd = com.gitblit.utils.FileUtils.readContent(pmkd, "\n"); |
| | | projectMarkdownCache.updateObject(name, lm, mkd); |
| | | } |
| | | project.projectMarkdown = projectMarkdownCache.getObject(name); |
| | | } |
| | | |
| | | // project repositories markdown |
| | | File rmkd = new File(getRepositoriesFolder(), (project.isRoot ? "" : name) + "/repositories.mkd"); |
| | | if (rmkd.exists()) { |
| | | Date lm = new Date(rmkd.lastModified()); |
| | | if (!projectRepositoriesMarkdownCache.hasCurrent(name, lm)) { |
| | | String mkd = com.gitblit.utils.FileUtils.readContent(rmkd, "\n"); |
| | | projectRepositoriesMarkdownCache.updateObject(name, lm, mkd); |
| | | } |
| | | project.repositoriesMarkdown = projectRepositoriesMarkdownCache.getObject(name); |
| | | } |
| | | |
| | | |
| | | reloadProjectMarkdown(project); |
| | | |
| | | configs.put(name.toLowerCase(), project); |
| | | } |
| | | projectCache.clear(); |
| | |
| | | } |
| | | return projectCache; |
| | | } |
| | | |
| | | |
| | | /** |
| | | * Returns a list of project models for the user. |
| | | * |
| | | * |
| | | * @param user |
| | | * @param includeUsers |
| | | * @return list of projects that are accessible to the user |
| | |
| | | Map<String, ProjectModel> map = new TreeMap<String, ProjectModel>(); |
| | | // root project |
| | | map.put("", configs.get("")); |
| | | |
| | | |
| | | for (RepositoryModel model : getRepositoryModels(user)) { |
| | | String rootPath = StringUtils.getRootPath(model.name).toLowerCase(); |
| | | String rootPath = StringUtils.getRootPath(model.name).toLowerCase(); |
| | | if (!map.containsKey(rootPath)) { |
| | | ProjectModel project; |
| | | if (configs.containsKey(rootPath)) { |
| | |
| | | } |
| | | map.get(rootPath).addRepository(model); |
| | | } |
| | | |
| | | |
| | | // sort projects, root project first |
| | | List<ProjectModel> projects; |
| | | if (includeUsers) { |
| | |
| | | } |
| | | return projects; |
| | | } |
| | | |
| | | |
| | | /** |
| | | * Returns the project model for the specified user. |
| | | * |
| | | * |
| | | * @param name |
| | | * @param user |
| | | * @return a project model, or null if it does not exist |
| | |
| | | } |
| | | return null; |
| | | } |
| | | |
| | | |
| | | /** |
| | | * Returns a project model for the Gitblit/system user. |
| | | * |
| | | * |
| | | * @param name a project name |
| | | * @return a project model or null if the project does not exist |
| | | */ |
| | |
| | | ProjectModel project = configs.get(name.toLowerCase()); |
| | | if (project == null) { |
| | | project = new ProjectModel(name); |
| | | if (name.length() > 0 && name.charAt(0) == '~') { |
| | | UserModel user = getUserModel(name.substring(1)); |
| | | if (ModelUtils.isPersonalRepository(name)) { |
| | | UserModel user = getUserModel(ModelUtils.getUserNameFromRepoPath(name)); |
| | | if (user != null) { |
| | | project.title = user.getDisplayName(); |
| | | project.description = "personal repositories"; |
| | |
| | | // no repositories == no project |
| | | return null; |
| | | } |
| | | |
| | | reloadProjectMarkdown(project); |
| | | return project; |
| | | } |
| | | |
| | | |
| | | /** |
| | | * Returns the list of project models that are referenced by the supplied |
| | | * repository model list. This is an alternative method exists to ensure |
| | | * Gitblit does not call getRepositoryModels(UserModel) twice in a request. |
| | | * |
| | | * |
| | | * @param repositoryModels |
| | | * @param includeUsers |
| | | * @return a list of project models |
| | |
| | | } |
| | | return new ArrayList<ProjectModel>(projects.values()); |
| | | } |
| | | |
| | | |
| | | /** |
| | | * Workaround JGit. I need to access the raw config object directly in order |
| | | * to see if the config is dirty so that I can reload a repository model. |
| | |
| | | * config. If the config changes are made within Gitblit this is fine as |
| | | * the returned config will still be flagged as dirty. BUT... if the config |
| | | * is manipulated outside Gitblit then it fails to recognize this as dirty. |
| | | * |
| | | * |
| | | * @param r |
| | | * @return a config |
| | | */ |
| | |
| | | } |
| | | return r.getConfig(); |
| | | } |
| | | |
| | | |
| | | /** |
| | | * Create a repository model from the configuration and repository data. |
| | | * |
| | | * |
| | | * @param repositoryName |
| | | * @return a repositoryModel or null if the repository does not exist |
| | | */ |
| | |
| | | // is symlinked. Use the provided repository name. |
| | | model.name = repositoryName; |
| | | } |
| | | model.hasCommits = JGitUtils.hasCommits(r); |
| | | model.lastChange = JGitUtils.getLastChange(r); |
| | | model.projectPath = StringUtils.getFirstPathElement(repositoryName); |
| | | |
| | | |
| | | StoredConfig config = r.getConfig(); |
| | | boolean hasOrigin = !StringUtils.isEmpty(config.getString("remote", "origin", "url")); |
| | | |
| | | |
| | | if (config != null) { |
| | | // Initialize description from description file |
| | | if (getConfig(config,"description", null) == null) { |
| | | File descFile = new File(r.getDirectory(), "description"); |
| | | if (descFile.exists()) { |
| | | String desc = com.gitblit.utils.FileUtils.readContent(descFile, System.getProperty("line.separator")); |
| | | if (!desc.toLowerCase().startsWith("unnamed repository")) { |
| | | config.setString(Constants.CONFIG_GITBLIT, null, "description", desc); |
| | | } |
| | | } |
| | | } |
| | | model.description = getConfig(config, "description", ""); |
| | | model.originRepository = getConfig(config, "originRepository", null); |
| | | model.addOwners(ArrayUtils.fromString(getConfig(config, "owner", ""))); |
| | | model.useTickets = getConfig(config, "useTickets", false); |
| | | model.useDocs = getConfig(config, "useDocs", false); |
| | | model.useIncrementalPushTags = getConfig(config, "useIncrementalPushTags", false); |
| | | model.incrementalPushTagPrefix = getConfig(config, "incrementalPushTagPrefix", null); |
| | | model.allowForks = getConfig(config, "allowForks", true); |
| | | model.accessRestriction = AccessRestrictionType.fromName(getConfig(config, |
| | | "accessRestriction", settings.getString(Keys.git.defaultAccessRestriction, null))); |
| | | "accessRestriction", settings.getString(Keys.git.defaultAccessRestriction, "PUSH"))); |
| | | model.authorizationControl = AuthorizationControl.fromName(getConfig(config, |
| | | "authorizationControl", settings.getString(Keys.git.defaultAuthorizationControl, null))); |
| | | model.verifyCommitter = getConfig(config, "verifyCommitter", false); |
| | | model.showRemoteBranches = getConfig(config, "showRemoteBranches", hasOrigin); |
| | | model.isFrozen = getConfig(config, "isFrozen", false); |
| | | model.showReadme = getConfig(config, "showReadme", false); |
| | | model.skipSizeCalculation = getConfig(config, "skipSizeCalculation", false); |
| | | model.skipSummaryMetrics = getConfig(config, "skipSummaryMetrics", false); |
| | | model.commitMessageRenderer = CommitMessageRenderer.fromName(getConfig(config, "commitMessageRenderer", |
| | | settings.getString(Keys.web.commitMessageRenderer, null))); |
| | | model.federationStrategy = FederationStrategy.fromName(getConfig(config, |
| | | "federationStrategy", null)); |
| | | model.federationSets = new ArrayList<String>(Arrays.asList(config.getStringList( |
| | |
| | | model.origin = config.getString("remote", "origin", "url"); |
| | | if (model.origin != null) { |
| | | model.origin = model.origin.replace('\\', '/'); |
| | | model.isMirror = config.getBoolean("remote", "origin", "mirror", false); |
| | | } |
| | | model.preReceiveScripts = new ArrayList<String>(Arrays.asList(config.getStringList( |
| | | Constants.CONFIG_GITBLIT, null, "preReceiveScript"))); |
| | |
| | | Constants.CONFIG_GITBLIT, null, "indexBranch"))); |
| | | model.metricAuthorExclusions = new ArrayList<String>(Arrays.asList(config.getStringList( |
| | | Constants.CONFIG_GITBLIT, null, "metricAuthorExclusions"))); |
| | | |
| | | |
| | | // Custom defined properties |
| | | model.customFields = new LinkedHashMap<String, String>(); |
| | | for (String aProperty : config.getNames(Constants.CONFIG_GITBLIT, Constants.CONFIG_CUSTOM_FIELDS)) { |
| | |
| | | model.HEAD = JGitUtils.getHEADRef(r); |
| | | model.availableRefs = JGitUtils.getAvailableHeadTargets(r); |
| | | model.sparkleshareId = JGitUtils.getSparkleshareId(r); |
| | | model.hasCommits = JGitUtils.hasCommits(r); |
| | | updateLastChangeFields(r, model); |
| | | r.close(); |
| | | |
| | | if (model.origin != null && model.origin.startsWith("file://")) { |
| | | |
| | | if (StringUtils.isEmpty(model.originRepository) && model.origin != null && model.origin.startsWith("file://")) { |
| | | // repository was cloned locally... perhaps as a fork |
| | | try { |
| | | File folder = new File(new URI(model.origin)); |
| | |
| | | File repoFolder = new File(getRepositoriesFolder(), originRepo); |
| | | if (repoFolder.exists()) { |
| | | model.originRepository = originRepo.toLowerCase(); |
| | | |
| | | // persist the fork origin |
| | | updateConfiguration(r, model); |
| | | } |
| | | } |
| | | } catch (URISyntaxException e) { |
| | |
| | | } |
| | | return model; |
| | | } |
| | | |
| | | |
| | | /** |
| | | * Determines if this server has the requested repository. |
| | | * |
| | | * |
| | | * @param n |
| | | * @return true if the repository exists |
| | | */ |
| | | public boolean hasRepository(String repositoryName) { |
| | | return hasRepository(repositoryName, false); |
| | | } |
| | | |
| | | |
| | | /** |
| | | * Determines if this server has the requested repository. |
| | | * |
| | | * |
| | | * @param n |
| | | * @param caseInsensitive |
| | | * @return true if the repository exists |
| | |
| | | // if we are caching use the cache to determine availability |
| | | // otherwise we end up adding a phantom repository to the cache |
| | | return repositoryListCache.containsKey(repositoryName.toLowerCase()); |
| | | } |
| | | } |
| | | Repository r = getRepository(repositoryName, false); |
| | | if (r == null) { |
| | | return false; |
| | |
| | | r.close(); |
| | | return true; |
| | | } |
| | | |
| | | |
| | | /** |
| | | * Determines if the specified user has a fork of the specified origin |
| | | * repository. |
| | | * |
| | | * |
| | | * @param username |
| | | * @param origin |
| | | * @return true the if the user has a fork |
| | |
| | | public boolean hasFork(String username, String origin) { |
| | | return getFork(username, origin) != null; |
| | | } |
| | | |
| | | |
| | | /** |
| | | * Gets the name of a user's fork of the specified origin |
| | | * repository. |
| | | * |
| | | * |
| | | * @param username |
| | | * @param origin |
| | | * @return the name of the user's fork, null otherwise |
| | | */ |
| | | public String getFork(String username, String origin) { |
| | | String userProject = "~" + username.toLowerCase(); |
| | | String userProject = ModelUtils.getPersonalPath(username); |
| | | if (settings.getBoolean(Keys.git.cacheRepositoryList, true)) { |
| | | String userPath = userProject + "/"; |
| | | |
| | |
| | | } |
| | | } |
| | | } |
| | | |
| | | |
| | | if (originModel.originRepository != null) { |
| | | roots.add(originModel.originRepository); |
| | | originModel = repositoryListCache.get(originModel.originRepository); |
| | |
| | | originModel = null; |
| | | } |
| | | } |
| | | |
| | | |
| | | for (String repository : repositoryListCache.keySet()) { |
| | | if (repository.startsWith(userPath)) { |
| | | RepositoryModel model = repositoryListCache.get(repository); |
| | |
| | | // user does not have a fork |
| | | return null; |
| | | } |
| | | |
| | | |
| | | /** |
| | | * Returns the fork network for a repository by traversing up the fork graph |
| | | * to discover the root and then down through all children of the root node. |
| | | * |
| | | * |
| | | * @param repository |
| | | * @return a ForkModel |
| | | */ |
| | |
| | | return root; |
| | | } |
| | | } |
| | | |
| | | |
| | | private ForkModel getForkModelFromCache(String repository) { |
| | | RepositoryModel model = repositoryListCache.get(repository.toLowerCase()); |
| | | if (model == null) { |
| | |
| | | } |
| | | return fork; |
| | | } |
| | | |
| | | |
| | | private ForkModel getForkModel(String repository) { |
| | | RepositoryModel model = getRepositoryModel(repository.toLowerCase()); |
| | | if (model == null) { |
| | |
| | | } |
| | | |
| | | /** |
| | | * Returns the size in bytes of the repository. Gitblit caches the |
| | | * repository sizes to reduce the performance penalty of recursive |
| | | * calculation. The cache is updated if the repository has been changed |
| | | * since the last calculation. |
| | | * |
| | | * Updates the last changed fields and optionally calculates the size of the |
| | | * repository. Gitblit caches the repository sizes to reduce the performance |
| | | * penalty of recursive calculation. The cache is updated if the repository |
| | | * has been changed since the last calculation. |
| | | * |
| | | * @param model |
| | | * @return size in bytes |
| | | * @return size in bytes of the repository |
| | | */ |
| | | public long calculateSize(RepositoryModel model) { |
| | | if (repositorySizeCache.hasCurrent(model.name, model.lastChange)) { |
| | | return repositorySizeCache.getObject(model.name); |
| | | public long updateLastChangeFields(Repository r, RepositoryModel model) { |
| | | LastChange lc = JGitUtils.getLastChange(r); |
| | | model.lastChange = lc.when; |
| | | model.lastChangeAuthor = lc.who; |
| | | |
| | | if (!getBoolean(Keys.web.showRepositorySizes, true) || model.skipSizeCalculation) { |
| | | model.size = null; |
| | | return 0L; |
| | | } |
| | | File gitDir = FileKey.resolve(new File(repositoriesFolder, model.name), FS.DETECTED); |
| | | long size = com.gitblit.utils.FileUtils.folderSize(gitDir); |
| | | repositorySizeCache.updateObject(model.name, model.lastChange, size); |
| | | if (!repositorySizeCache.hasCurrent(model.name, model.lastChange)) { |
| | | File gitDir = r.getDirectory(); |
| | | long sz = com.gitblit.utils.FileUtils.folderSize(gitDir); |
| | | repositorySizeCache.updateObject(model.name, model.lastChange, sz); |
| | | } |
| | | long size = repositorySizeCache.getObject(model.name); |
| | | ByteFormat byteFormat = new ByteFormat(); |
| | | model.size = byteFormat.format(size); |
| | | return size; |
| | | } |
| | | |
| | | /** |
| | | * Ensure that a cached repository is completely closed and its resources |
| | | * are properly released. |
| | | * |
| | | * |
| | | * @param repositoryName |
| | | */ |
| | | private void closeRepository(String repositoryName) { |
| | |
| | | repository.close(); |
| | | } |
| | | } |
| | | |
| | | |
| | | // close any open index writer/searcher in the Lucene executor |
| | | luceneExecutor.close(repositoryName); |
| | | } |
| | |
| | | * This method builds a metrics cache. The cache is updated if the |
| | | * repository is updated. A new copy of the metrics list is returned on each |
| | | * call so that modifications to the list are non-destructive. |
| | | * |
| | | * |
| | | * @param model |
| | | * @param repository |
| | | * @return a new array list of metrics |
| | |
| | | /** |
| | | * Returns the gitblit string value for the specified key. If key is not |
| | | * set, returns defaultValue. |
| | | * |
| | | * |
| | | * @param config |
| | | * @param field |
| | | * @param defaultValue |
| | |
| | | /** |
| | | * Returns the gitblit boolean value for the specified key. If key is not |
| | | * set, returns defaultValue. |
| | | * |
| | | * |
| | | * @param config |
| | | * @param field |
| | | * @param defaultValue |
| | |
| | | private boolean getConfig(StoredConfig config, String field, boolean defaultValue) { |
| | | return config.getBoolean(Constants.CONFIG_GITBLIT, field, defaultValue); |
| | | } |
| | | |
| | | |
| | | /** |
| | | * Returns the gitblit string value for the specified key. If key is not |
| | | * set, returns defaultValue. |
| | | * |
| | | * |
| | | * @param config |
| | | * @param field |
| | | * @param defaultValue |
| | |
| | | * Creates/updates the repository model keyed by reopsitoryName. Saves all |
| | | * repository settings in .git/config. This method allows for renaming |
| | | * repositories and will update user access permissions accordingly. |
| | | * |
| | | * |
| | | * All repositories created by this method are bare and automatically have |
| | | * .git appended to their names, which is the standard convention for bare |
| | | * repositories. |
| | | * |
| | | * |
| | | * @param repositoryName |
| | | * @param repository |
| | | * @param isCreate |
| | |
| | | } |
| | | // create repository |
| | | logger.info("create repository " + repository.name); |
| | | r = JGitUtils.createRepository(repositoriesFolder, repository.name); |
| | | String shared = getString(Keys.git.createRepositoriesShared, "FALSE"); |
| | | r = JGitUtils.createRepository(repositoriesFolder, repository.name, shared); |
| | | } else { |
| | | // rename repository |
| | | if (!repositoryName.equalsIgnoreCase(repository.name)) { |
| | |
| | | "Failed to rename repository permissions ''{0}'' to ''{1}''.", |
| | | repositoryName, repository.name)); |
| | | } |
| | | |
| | | |
| | | // rename fork origins in their configs |
| | | if (!ArrayUtils.isEmpty(repository.forks)) { |
| | | for (String fork : repository.forks) { |
| | |
| | | String origin = config.getString("remote", "origin", "url"); |
| | | origin = origin.replace(repositoryName, repository.name); |
| | | config.setString("remote", "origin", "url", origin); |
| | | config.setString(Constants.CONFIG_GITBLIT, null, "originRepository", repository.name); |
| | | config.save(); |
| | | } catch (Exception e) { |
| | | logger.error("Failed to update repository fork config for " + fork, e); |
| | |
| | | rf.close(); |
| | | } |
| | | } |
| | | |
| | | // remove this repository from any origin model's fork list |
| | | |
| | | // update this repository's origin's fork list |
| | | if (!StringUtils.isEmpty(repository.originRepository)) { |
| | | RepositoryModel origin = repositoryListCache.get(repository.originRepository); |
| | | if (origin != null && !ArrayUtils.isEmpty(origin.forks)) { |
| | | origin.forks.remove(repositoryName); |
| | | origin.forks.add(repository.name); |
| | | } |
| | | } |
| | | |
| | |
| | | // update settings |
| | | if (r != null) { |
| | | updateConfiguration(r, repository); |
| | | // Update the description file |
| | | File descFile = new File(r.getDirectory(), "description"); |
| | | if (repository.description != null) |
| | | { |
| | | com.gitblit.utils.FileUtils.writeContent(descFile, repository.description); |
| | | } |
| | | else if (descFile.exists() && !descFile.isDirectory()) { |
| | | descFile.delete(); |
| | | } |
| | | // only update symbolic head if it changes |
| | | String currentRef = JGitUtils.getHEADRef(r); |
| | | if (!StringUtils.isEmpty(repository.HEAD) && !repository.HEAD.equals(currentRef)) { |
| | | logger.info(MessageFormat.format("Relinking {0} HEAD from {1} to {2}", |
| | | logger.info(MessageFormat.format("Relinking {0} HEAD from {1} to {2}", |
| | | repository.name, currentRef, repository.HEAD)); |
| | | if (JGitUtils.setHEADtoRef(r, repository.HEAD)) { |
| | | // clear the cache |
| | |
| | | } |
| | | } |
| | | |
| | | // Adjust permissions in case we updated the config files |
| | | JGitUtils.adjustSharedPerm(new File(r.getDirectory().getAbsolutePath(), "config"), |
| | | getString(Keys.git.createRepositoriesShared, "FALSE")); |
| | | JGitUtils.adjustSharedPerm(new File(r.getDirectory().getAbsolutePath(), "HEAD"), |
| | | getString(Keys.git.createRepositoriesShared, "FALSE")); |
| | | |
| | | // close the repository object |
| | | r.close(); |
| | | } |
| | | |
| | | |
| | | // update repository cache |
| | | removeFromCachedRepositoryList(repositoryName); |
| | | // model will actually be replaced on next load because config is stale |
| | | addToCachedRepositoryList(repository); |
| | | } |
| | | |
| | | |
| | | /** |
| | | * Updates the Gitblit configuration for the specified repository. |
| | | * |
| | | * |
| | | * @param r |
| | | * the Git repository |
| | | * @param repository |
| | |
| | | public void updateConfiguration(Repository r, RepositoryModel repository) { |
| | | StoredConfig config = r.getConfig(); |
| | | config.setString(Constants.CONFIG_GITBLIT, null, "description", repository.description); |
| | | config.setString(Constants.CONFIG_GITBLIT, null, "originRepository", repository.originRepository); |
| | | config.setString(Constants.CONFIG_GITBLIT, null, "owner", ArrayUtils.toString(repository.owners)); |
| | | config.setBoolean(Constants.CONFIG_GITBLIT, null, "useTickets", repository.useTickets); |
| | | config.setBoolean(Constants.CONFIG_GITBLIT, null, "useDocs", repository.useDocs); |
| | | config.setBoolean(Constants.CONFIG_GITBLIT, null, "useIncrementalPushTags", repository.useIncrementalPushTags); |
| | | if (StringUtils.isEmpty(repository.incrementalPushTagPrefix) || |
| | |
| | | config.setBoolean(Constants.CONFIG_GITBLIT, null, "verifyCommitter", repository.verifyCommitter); |
| | | config.setBoolean(Constants.CONFIG_GITBLIT, null, "showRemoteBranches", repository.showRemoteBranches); |
| | | config.setBoolean(Constants.CONFIG_GITBLIT, null, "isFrozen", repository.isFrozen); |
| | | config.setBoolean(Constants.CONFIG_GITBLIT, null, "showReadme", repository.showReadme); |
| | | config.setBoolean(Constants.CONFIG_GITBLIT, null, "skipSizeCalculation", repository.skipSizeCalculation); |
| | | config.setBoolean(Constants.CONFIG_GITBLIT, null, "skipSummaryMetrics", repository.skipSummaryMetrics); |
| | | config.setString(Constants.CONFIG_GITBLIT, null, "federationStrategy", |
| | |
| | | config.setInt(Constants.CONFIG_GITBLIT, null, "maxActivityCommits", repository.maxActivityCommits); |
| | | } |
| | | |
| | | CommitMessageRenderer defaultRenderer = CommitMessageRenderer.fromName(settings.getString(Keys.web.commitMessageRenderer, null)); |
| | | if (repository.commitMessageRenderer == null || repository.commitMessageRenderer == defaultRenderer) { |
| | | // use default from config |
| | | config.unset(Constants.CONFIG_GITBLIT, null, "commitMessageRenderer"); |
| | | } else { |
| | | // repository overrides default |
| | | config.setString(Constants.CONFIG_GITBLIT, null, "commitMessageRenderer", |
| | | repository.commitMessageRenderer.name()); |
| | | } |
| | | |
| | | updateList(config, "federationSets", repository.federationSets); |
| | | updateList(config, "preReceiveScript", repository.preReceiveScripts); |
| | | updateList(config, "postReceiveScript", repository.postReceiveScripts); |
| | | updateList(config, "mailingList", repository.mailingLists); |
| | | updateList(config, "indexBranch", repository.indexedBranches); |
| | | updateList(config, "metricAuthorExclusions", repository.metricAuthorExclusions); |
| | | |
| | | |
| | | // User Defined Properties |
| | | if (repository.customFields != null) { |
| | | if (repository.customFields.size() == 0) { |
| | |
| | | logger.error("Failed to save repository config!", e); |
| | | } |
| | | } |
| | | |
| | | |
| | | private void updateList(StoredConfig config, String field, List<String> list) { |
| | | // a null list is skipped, not cleared |
| | | // this is for RPC administration where an older manager might be used |
| | |
| | | /** |
| | | * Deletes the repository from the file system and removes the repository |
| | | * permission from all repository users. |
| | | * |
| | | * |
| | | * @param model |
| | | * @return true if successful |
| | | */ |
| | |
| | | /** |
| | | * Deletes the repository from the file system and removes the repository |
| | | * permission from all repository users. |
| | | * |
| | | * |
| | | * @param repositoryName |
| | | * @return true if successful |
| | | */ |
| | |
| | | closeRepository(repositoryName); |
| | | // clear the repository cache |
| | | clearRepositoryMetadataCache(repositoryName); |
| | | |
| | | |
| | | RepositoryModel model = removeFromCachedRepositoryList(repositoryName); |
| | | if (model != null && !ArrayUtils.isEmpty(model.forks)) { |
| | | resetRepositoryListCache(); |
| | |
| | | /** |
| | | * Returns an html version of the commit message with any global or |
| | | * repository-specific regular expression substitution applied. |
| | | * |
| | | * |
| | | * This method uses the preferred renderer to transform the commit message. |
| | | * |
| | | * @param repository |
| | | * @param text |
| | | * @return html version of the commit message |
| | | */ |
| | | public String processCommitMessage(RepositoryModel repository, String text) { |
| | | switch (repository.commitMessageRenderer) { |
| | | case MARKDOWN: |
| | | try { |
| | | String prepared = processCommitMessageRegex(repository.name, text); |
| | | return MarkdownUtils.transformMarkdown(prepared); |
| | | } catch (Exception e) { |
| | | logger.error("Failed to render commit message as markdown", e); |
| | | } |
| | | break; |
| | | default: |
| | | // noop |
| | | break; |
| | | } |
| | | |
| | | return processPlainCommitMessage(repository.name, text); |
| | | } |
| | | |
| | | /** |
| | | * Returns an html version of the commit message with any global or |
| | | * repository-specific regular expression substitution applied. |
| | | * |
| | | * This method assumes the commit message is plain text. |
| | | * |
| | | * @param repositoryName |
| | | * @param text |
| | | * @return html version of the commit message |
| | | */ |
| | | public String processCommitMessage(String repositoryName, String text) { |
| | | String html = StringUtils.breakLinesForHtml(text); |
| | | public String processPlainCommitMessage(String repositoryName, String text) { |
| | | String html = StringUtils.escapeForHtml(text, false); |
| | | html = processCommitMessageRegex(repositoryName, html); |
| | | return StringUtils.breakLinesForHtml(html); |
| | | |
| | | } |
| | | |
| | | /** |
| | | * Apply globally or per-repository specified regex substitutions to the |
| | | * commit message. |
| | | * |
| | | * @param repositoryName |
| | | * @param text |
| | | * @return the processed commit message |
| | | */ |
| | | protected String processCommitMessageRegex(String repositoryName, String text) { |
| | | Map<String, String> map = new HashMap<String, String>(); |
| | | // global regex keys |
| | | if (settings.getBoolean(Keys.regex.global, false)) { |
| | |
| | | String definition = entry.getValue().trim(); |
| | | String[] chunks = definition.split("!!!"); |
| | | if (chunks.length == 2) { |
| | | html = html.replaceAll(chunks[0], chunks[1]); |
| | | text = text.replaceAll(chunks[0], chunks[1]); |
| | | } else { |
| | | logger.warn(entry.getKey() |
| | | + " improperly formatted. Use !!! to separate match from replacement: " |
| | | + definition); |
| | | } |
| | | } |
| | | return html; |
| | | return text; |
| | | } |
| | | |
| | | /** |
| | | * Returns Gitblit's scheduled executor service for scheduling tasks. |
| | | * |
| | | * |
| | | * @return scheduledExecutor |
| | | */ |
| | | public ScheduledExecutorService executor() { |
| | |
| | | /** |
| | | * Returns the list of federated gitblit instances that this instance will |
| | | * try to pull. |
| | | * |
| | | * |
| | | * @return list of registered gitblit instances |
| | | */ |
| | | public List<FederationModel> getFederationRegistrations() { |
| | |
| | | |
| | | /** |
| | | * Retrieve the specified federation registration. |
| | | * |
| | | * |
| | | * @param name |
| | | * the name of the registration |
| | | * @return a federation registration |
| | |
| | | |
| | | /** |
| | | * Returns the list of federation sets. |
| | | * |
| | | * |
| | | * @return list of federation sets |
| | | */ |
| | | public List<FederationSet> getFederationSets(String gitblitUrl) { |
| | |
| | | |
| | | /** |
| | | * Returns the list of possible federation tokens for this Gitblit instance. |
| | | * |
| | | * |
| | | * @return list of federation tokens |
| | | */ |
| | | public List<String> getFederationTokens() { |
| | |
| | | |
| | | /** |
| | | * Returns the specified federation token for this Gitblit instance. |
| | | * |
| | | * |
| | | * @param type |
| | | * @return a federation token |
| | | */ |
| | |
| | | |
| | | /** |
| | | * Returns the specified federation token for this Gitblit instance. |
| | | * |
| | | * |
| | | * @param value |
| | | * @return a federation token |
| | | */ |
| | |
| | | /** |
| | | * Compares the provided token with this Gitblit instance's tokens and |
| | | * determines if the requested permission may be granted to the token. |
| | | * |
| | | * |
| | | * @param req |
| | | * @param token |
| | | * @return true if the request can be executed |
| | |
| | | |
| | | /** |
| | | * Acknowledge and cache the status of a remote Gitblit instance. |
| | | * |
| | | * |
| | | * @param identification |
| | | * the identification of the pulling Gitblit instance |
| | | * @param registration |
| | |
| | | |
| | | /** |
| | | * Returns the list of registration results. |
| | | * |
| | | * |
| | | * @return the list of registration results |
| | | */ |
| | | public List<FederationModel> getFederationResultRegistrations() { |
| | |
| | | /** |
| | | * Submit a federation proposal. The proposal is cached locally and the |
| | | * Gitblit administrator(s) are notified via email. |
| | | * |
| | | * |
| | | * @param proposal |
| | | * the proposal |
| | | * @param gitblitUrl |
| | |
| | | |
| | | /** |
| | | * Returns the list of pending federation proposals |
| | | * |
| | | * |
| | | * @return list of federation proposals |
| | | */ |
| | | public List<FederationProposal> getPendingFederationProposals() { |
| | |
| | | |
| | | /** |
| | | * Get repositories for the specified token. |
| | | * |
| | | * |
| | | * @param gitblitUrl |
| | | * the base url of this gitblit instance |
| | | * @param token |
| | |
| | | String cloneUrl = sb.toString(); |
| | | |
| | | // Retrieve all available repositories |
| | | UserModel user = new UserModel(Constants.FEDERATION_USER); |
| | | user.canAdmin = true; |
| | | UserModel user = getFederationUser(); |
| | | List<RepositoryModel> list = getRepositoryModels(user); |
| | | |
| | | // create the [cloneurl, repositoryModel] map |
| | |
| | | |
| | | /** |
| | | * Creates a proposal from the token. |
| | | * |
| | | * |
| | | * @param gitblitUrl |
| | | * the url of this Gitblit instance |
| | | * @param token |
| | |
| | | |
| | | /** |
| | | * Returns the proposal identified by the supplied token. |
| | | * |
| | | * |
| | | * @param token |
| | | * @return the specified proposal or null |
| | | */ |
| | |
| | | |
| | | /** |
| | | * Deletes a pending federation proposal. |
| | | * |
| | | * |
| | | * @param a |
| | | * proposal |
| | | * @return true if the proposal was deleted |
| | |
| | | /** |
| | | * Returns the list of all Groovy push hook scripts. Script files must have |
| | | * .groovy extension |
| | | * |
| | | * |
| | | * @return list of available hook scripts |
| | | */ |
| | | public List<String> getAllScripts() { |
| | |
| | | /** |
| | | * Returns the list of pre-receive scripts the repository inherited from the |
| | | * global settings and team affiliations. |
| | | * |
| | | * |
| | | * @param repository |
| | | * if null only the globally specified scripts are returned |
| | | * @return a list of scripts |
| | |
| | | * Returns the list of all available Groovy pre-receive push hook scripts |
| | | * that are not already inherited by the repository. Script files must have |
| | | * .groovy extension |
| | | * |
| | | * |
| | | * @param repository |
| | | * optional parameter |
| | | * @return list of available hook scripts |
| | |
| | | /** |
| | | * Returns the list of post-receive scripts the repository inherited from |
| | | * the global settings and team affiliations. |
| | | * |
| | | * |
| | | * @param repository |
| | | * if null only the globally specified scripts are returned |
| | | * @return a list of scripts |
| | |
| | | * Returns the list of unused Groovy post-receive push hook scripts that are |
| | | * not already inherited by the repository. Script files must have .groovy |
| | | * extension |
| | | * |
| | | * |
| | | * @param repository |
| | | * optional parameter |
| | | * @return list of available hook scripts |
| | |
| | | } |
| | | return scripts; |
| | | } |
| | | |
| | | |
| | | /** |
| | | * Search the specified repositories using the Lucene query. |
| | | * |
| | | * |
| | | * @param query |
| | | * @param page |
| | | * @param pageSize |
| | | * @param repositories |
| | | * @return |
| | | */ |
| | | public List<SearchResult> search(String query, int page, int pageSize, List<String> repositories) { |
| | | public List<SearchResult> search(String query, int page, int pageSize, List<String> repositories) { |
| | | List<SearchResult> srs = luceneExecutor.search(query, page, pageSize, repositories); |
| | | return srs; |
| | | } |
| | | |
| | | /** |
| | | * Notify the administrators by email. |
| | | * |
| | | * |
| | | * @param subject |
| | | * @param message |
| | | */ |
| | |
| | | |
| | | /** |
| | | * Notify users by email of something. |
| | | * |
| | | * |
| | | * @param subject |
| | | * @param message |
| | | * @param toAddresses |
| | |
| | | |
| | | /** |
| | | * Notify users by email of something. |
| | | * |
| | | * |
| | | * @param subject |
| | | * @param message |
| | | * @param toAddresses |
| | |
| | | Message mail = mailExecutor.createMessage(toAddresses); |
| | | if (mail != null) { |
| | | mail.setSubject(subject); |
| | | |
| | | MimeBodyPart messagePart = new MimeBodyPart(); |
| | | |
| | | MimeBodyPart messagePart = new MimeBodyPart(); |
| | | messagePart.setText(message, "utf-8"); |
| | | messagePart.setHeader("Content-Type", "text/plain; charset=\"utf-8\""); |
| | | messagePart.setHeader("Content-Transfer-Encoding", "quoted-printable"); |
| | | |
| | | |
| | | MimeMultipart multiPart = new MimeMultipart(); |
| | | multiPart.addBodyPart(messagePart); |
| | | mail.setContent(multiPart); |
| | | |
| | | |
| | | mailExecutor.queue(mail); |
| | | } |
| | | } catch (MessagingException e) { |
| | |
| | | |
| | | /** |
| | | * Notify users by email of something. |
| | | * |
| | | * |
| | | * @param subject |
| | | * @param message |
| | | * @param toAddresses |
| | |
| | | |
| | | /** |
| | | * Notify users by email of something. |
| | | * |
| | | * |
| | | * @param subject |
| | | * @param message |
| | | * @param toAddresses |
| | |
| | | Message mail = mailExecutor.createMessage(toAddresses); |
| | | if (mail != null) { |
| | | mail.setSubject(subject); |
| | | |
| | | MimeBodyPart messagePart = new MimeBodyPart(); |
| | | |
| | | MimeBodyPart messagePart = new MimeBodyPart(); |
| | | messagePart.setText(message, "utf-8"); |
| | | messagePart.setHeader("Content-Type", "text/html; charset=\"utf-8\""); |
| | | messagePart.setHeader("Content-Transfer-Encoding", "quoted-printable"); |
| | | |
| | | |
| | | MimeMultipart multiPart = new MimeMultipart(); |
| | | multiPart.addBodyPart(messagePart); |
| | | mail.setContent(multiPart); |
| | |
| | | |
| | | /** |
| | | * Returns the descriptions/comments of the Gitblit config settings. |
| | | * |
| | | * |
| | | * @return SettingsModel |
| | | */ |
| | | public ServerSettings getSettingsModel() { |
| | |
| | | setting.name = key; |
| | | settingsModel.add(setting); |
| | | } |
| | | setting.currentValue = settings.getString(key, ""); |
| | | setting.currentValue = settings.getString(key, ""); |
| | | } |
| | | settingsModel.pushScripts = getAllScripts(); |
| | | return settingsModel; |
| | |
| | | * Parse the properties file and aggregate all the comments by the setting |
| | | * key. A setting model tracks the current value, the default value, the |
| | | * description of the setting and and directives about the setting. |
| | | * |
| | | * |
| | | * @return Map<String, SettingModel> |
| | | */ |
| | | private ServerSettings loadSettingModels() { |
| | |
| | | * Configure the Gitblit singleton with the specified settings source. This |
| | | * source may be file settings (Gitblit GO) or may be web.xml settings |
| | | * (Gitblit WAR). |
| | | * |
| | | * |
| | | * @param settings |
| | | */ |
| | | public void configureContext(IStoredSettings settings, File folder, boolean startFederation) { |
| | |
| | | mailExecutor = new MailExecutor(settings); |
| | | luceneExecutor = new LuceneExecutor(settings, repositoriesFolder); |
| | | gcExecutor = new GCExecutor(settings); |
| | | |
| | | mirrorExecutor = new MirrorExecutor(settings); |
| | | |
| | | // initialize utilities |
| | | String prefix = settings.getString(Keys.git.userRepositoryPrefix, "~"); |
| | | ModelUtils.setUserRepoPrefix(prefix); |
| | | |
| | | // calculate repository list settings checksum for future config changes |
| | | repositoryListSettingsChecksum.set(getRepositoryListSettingsChecksum()); |
| | | |
| | |
| | | logger.info("Identifying available repositories..."); |
| | | getRepositoryList(); |
| | | } |
| | | |
| | | |
| | | logTimezone("JVM", TimeZone.getDefault()); |
| | | logTimezone(Constants.NAME, getTimezone()); |
| | | |
| | |
| | | } |
| | | setUserService(loginService); |
| | | } |
| | | |
| | | |
| | | // load and cache the project metadata |
| | | projectConfigs = new FileBasedConfig(getFileOrFolder(Keys.web.projectsFile, "${baseFolder}/projects.conf"), FS.detect()); |
| | | getProjectConfigs(); |
| | | |
| | | configureMailExecutor(); |
| | | |
| | | configureMailExecutor(); |
| | | configureLuceneIndexing(); |
| | | configureGarbageCollector(); |
| | | configureMirrorExecutor(); |
| | | if (startFederation) { |
| | | configureFederation(); |
| | | } |
| | | configureJGit(); |
| | | configureFanout(); |
| | | configureGitDaemon(); |
| | | |
| | | configureCommitCache(); |
| | | |
| | | ContainerUtils.CVE_2007_0450.test(); |
| | | } |
| | | |
| | | |
| | | protected void configureMailExecutor() { |
| | | if (mailExecutor.isReady()) { |
| | | logger.info("Mail executor is scheduled to process the message queue every 2 minutes."); |
| | |
| | | logger.warn("Mail server is not properly configured. Mail services disabled."); |
| | | } |
| | | } |
| | | |
| | | |
| | | protected void configureLuceneIndexing() { |
| | | scheduledExecutor.scheduleAtFixedRate(luceneExecutor, 1, 2, TimeUnit.MINUTES); |
| | | logger.info("Lucene executor is scheduled to process indexed branches every 2 minutes."); |
| | | } |
| | | |
| | | |
| | | protected void configureGarbageCollector() { |
| | | // schedule gc engine |
| | | if (gcExecutor.isReady()) { |
| | |
| | | delay = (int) ((cd.getTime() - now.getTime())/TimeUtils.MIN); |
| | | String when = delay + " mins"; |
| | | if (delay > 60) { |
| | | when = MessageFormat.format("{0,number,0.0} hours", ((float)delay)/60f); |
| | | when = MessageFormat.format("{0,number,0.0} hours", (delay)/60f); |
| | | } |
| | | logger.info(MessageFormat.format("Next scheculed GC scan is in {0}", when)); |
| | | scheduledExecutor.scheduleAtFixedRate(gcExecutor, delay, 60*24, TimeUnit.MINUTES); |
| | | } |
| | | } |
| | | |
| | | |
| | | protected void configureMirrorExecutor() { |
| | | if (mirrorExecutor.isReady()) { |
| | | int mins = TimeUtils.convertFrequencyToMinutes(settings.getString(Keys.git.mirrorPeriod, "30 mins")); |
| | | if (mins < 5) { |
| | | mins = 5; |
| | | } |
| | | int delay = 1; |
| | | scheduledExecutor.scheduleAtFixedRate(mirrorExecutor, delay, mins, TimeUnit.MINUTES); |
| | | logger.info("Mirror executor is scheduled to fetch updates every {} minutes.", mins); |
| | | logger.info("Next scheduled mirror fetch is in {} minutes", delay); |
| | | } |
| | | } |
| | | |
| | | protected void configureJGit() { |
| | | // Configure JGit |
| | | WindowCacheConfig cfg = new WindowCacheConfig(); |
| | |
| | | logger.error("Failed to configure JGit parameters!", e); |
| | | } |
| | | } |
| | | |
| | | |
| | | protected void configureFanout() { |
| | | // startup Fanout PubSub service |
| | | if (settings.getInteger(Keys.fanout.port, 0) > 0) { |
| | |
| | | fanoutService.start(); |
| | | } |
| | | } |
| | | |
| | | |
| | | protected void configureGitDaemon() { |
| | | int port = settings.getInteger(Keys.git.daemonPort, 0); |
| | | String bindInterface = settings.getString(Keys.git.daemonBindInterface, "localhost"); |
| | |
| | | } |
| | | } |
| | | } |
| | | |
| | | |
| | | protected void configureCommitCache() { |
| | | int daysToCache = settings.getInteger(Keys.web.activityCacheDays, 14); |
| | | if (daysToCache <= 0) { |
| | | logger.info("commit cache disabled"); |
| | | } else { |
| | | long start = System.nanoTime(); |
| | | long repoCount = 0; |
| | | long commitCount = 0; |
| | | logger.info(MessageFormat.format("preparing {0} day commit cache. please wait...", daysToCache)); |
| | | CommitCache.instance().setCacheDays(daysToCache); |
| | | Date cutoff = CommitCache.instance().getCutoffDate(); |
| | | for (String repositoryName : getRepositoryList()) { |
| | | RepositoryModel model = getRepositoryModel(repositoryName); |
| | | if (model != null && model.hasCommits && model.lastChange.after(cutoff)) { |
| | | repoCount++; |
| | | Repository repository = getRepository(repositoryName); |
| | | for (RefModel ref : JGitUtils.getLocalBranches(repository, true, -1)) { |
| | | if (!ref.getDate().after(cutoff)) { |
| | | // branch not recently updated |
| | | continue; |
| | | } |
| | | List<?> commits = CommitCache.instance().getCommits(repositoryName, repository, ref.getName()); |
| | | if (commits.size() > 0) { |
| | | logger.info(MessageFormat.format(" cached {0} commits for {1}:{2}", |
| | | commits.size(), repositoryName, ref.getName())); |
| | | commitCount += commits.size(); |
| | | } |
| | | } |
| | | repository.close(); |
| | | } |
| | | } |
| | | logger.info(MessageFormat.format("built {0} day commit cache of {1} commits across {2} repositories in {3} msecs", |
| | | daysToCache, commitCount, repoCount, TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start))); |
| | | } |
| | | } |
| | | |
| | | protected final Logger getLogger() { |
| | | return logger; |
| | | } |
| | | |
| | | |
| | | protected final ScheduledExecutorService getScheduledExecutor() { |
| | | return scheduledExecutor; |
| | | } |
| | |
| | | protected final LuceneExecutor getLuceneExecutor() { |
| | | return luceneExecutor; |
| | | } |
| | | |
| | | |
| | | private void logTimezone(String type, TimeZone zone) { |
| | | SimpleDateFormat df = new SimpleDateFormat("z Z"); |
| | | df.setTimeZone(zone); |
| | |
| | | /** |
| | | * Configure Gitblit from the web.xml, if no configuration has already been |
| | | * specified. |
| | | * |
| | | * |
| | | * @see ServletContextListener.contextInitialize(ServletContextEvent) |
| | | */ |
| | | @Override |
| | |
| | | String contextRealPath = context.getRealPath("/"); |
| | | File contextFolder = (contextRealPath != null) ? new File(contextRealPath) : null; |
| | | String openShift = System.getenv("OPENSHIFT_DATA_DIR"); |
| | | |
| | | |
| | | if (!StringUtils.isEmpty(openShift)) { |
| | | // Gitblit is running in OpenShift/JBoss |
| | | File base = new File(openShift); |
| | |
| | | // gitblit.properties setting overrides |
| | | File overrideFile = new File(base, "gitblit.properties"); |
| | | webxmlSettings.applyOverrides(overrideFile); |
| | | |
| | | |
| | | // Copy the included scripts to the configured groovy folder |
| | | String path = webxmlSettings.getString(Keys.groovy.scriptsFolder, "groovy"); |
| | | File localScripts = com.gitblit.utils.FileUtils.resolveParameter(Constants.baseFolder$, base, path); |
| | |
| | | } |
| | | } |
| | | } |
| | | |
| | | |
| | | // configure context using the web.xml |
| | | configureContext(webxmlSettings, base, true); |
| | | } else { |
| | | // Gitblit is running in a standard servlet container |
| | | logger.info("WAR contextFolder is " + ((contextFolder != null) ? contextFolder.getAbsolutePath() : "<empty>")); |
| | | |
| | | |
| | | String path = webxmlSettings.getString(Constants.baseFolder, Constants.contextFolder$ + "/WEB-INF/data"); |
| | | |
| | | |
| | | if (path.contains(Constants.contextFolder$) && contextFolder == null) { |
| | | // warn about null contextFolder (issue-199) |
| | | logger.error(""); |
| | |
| | | logger.error(MessageFormat.format("OR configure your servlet container to specify a \"{0}\" parameter in the context configuration!!", Constants.baseFolder)); |
| | | logger.error(""); |
| | | } |
| | | |
| | | |
| | | try { |
| | | // try to lookup JNDI env-entry for the baseFolder |
| | | InitialContext ic = new InitialContext(); |
| | | Context env = (Context) ic.lookup("java:comp/env"); |
| | | String val = (String) env.lookup("baseFolder"); |
| | | if (!StringUtils.isEmpty(val)) { |
| | | path = val; |
| | | } |
| | | } catch (NamingException n) { |
| | | logger.error("Failed to get JNDI env-entry: " + n.getExplanation()); |
| | | } |
| | | |
| | | File base = com.gitblit.utils.FileUtils.resolveParameter(Constants.contextFolder$, contextFolder, path); |
| | | base.mkdirs(); |
| | | |
| | |
| | | } |
| | | |
| | | // delegate all config to baseFolder/gitblit.properties file |
| | | FileSettings settings = new FileSettings(localSettings.getAbsolutePath()); |
| | | FileSettings settings = new FileSettings(localSettings.getAbsolutePath()); |
| | | configureContext(settings, base, true); |
| | | } |
| | | } |
| | | |
| | | |
| | | settingsModel = loadSettingModels(); |
| | | serverStatus.servletContainer = servletContext.getServerInfo(); |
| | | } |
| | | |
| | | |
| | | protected void extractResources(ServletContext context, String path, File toDir) { |
| | | for (String resource : context.getResourcePaths(path)) { |
| | | // extract the resource to the directory if it does not exist |
| | |
| | | scheduledExecutor.shutdownNow(); |
| | | luceneExecutor.close(); |
| | | gcExecutor.close(); |
| | | mirrorExecutor.close(); |
| | | if (fanoutService != null) { |
| | | fanoutService.stop(); |
| | | } |
| | |
| | | gitDaemon.stop(); |
| | | } |
| | | } |
| | | |
| | | |
| | | /** |
| | | * |
| | | * |
| | | * @return true if we are running the gc executor |
| | | */ |
| | | public boolean isCollectingGarbage() { |
| | | return gcExecutor.isRunning(); |
| | | } |
| | | |
| | | |
| | | /** |
| | | * Returns true if Gitblit is actively collecting garbage in this repository. |
| | | * |
| | | * |
| | | * @param repositoryName |
| | | * @return true if actively collecting garbage |
| | | */ |
| | |
| | | /** |
| | | * Creates a personal fork of the specified repository. The clone is view |
| | | * restricted by default and the owner of the source repository is given |
| | | * access to the clone. |
| | | * |
| | | * access to the clone. |
| | | * |
| | | * @param repository |
| | | * @param user |
| | | * @return the repository model of the fork, if successful |
| | | * @throws GitBlitException |
| | | */ |
| | | public RepositoryModel fork(RepositoryModel repository, UserModel user) throws GitBlitException { |
| | | String cloneName = MessageFormat.format("~{0}/{1}.git", user.username, StringUtils.stripDotGit(StringUtils.getLastPathElement(repository.name))); |
| | | String cloneName = MessageFormat.format("{0}/{1}.git", user.getPersonalPath(), StringUtils.stripDotGit(StringUtils.getLastPathElement(repository.name))); |
| | | String fromUrl = MessageFormat.format("file://{0}/{1}", repositoriesFolder.getAbsolutePath(), repository.name); |
| | | |
| | | // clone the repository |
| | |
| | | } |
| | | cloneTeams.add(cloneTeam); |
| | | } |
| | | userService.updateTeamModels(cloneTeams); |
| | | userService.updateTeamModels(cloneTeams); |
| | | |
| | | // add this clone to the cached model |
| | | addToCachedRepositoryList(cloneModel); |
| | |
| | | /** |
| | | * Allow to understand if GitBlit supports and is configured to allow |
| | | * cookie-based authentication. |
| | | * |
| | | * |
| | | * @return status of Cookie authentication enablement. |
| | | */ |
| | | public boolean allowCookieAuthentication() { |