Example usage for org.eclipse.jgit.transport.resolver FileResolver FileResolver

Introduction

In this page you can find the example usage for org.eclipse.jgit.transport.resolver FileResolver FileResolver.

Prototype

public FileResolver(File basePath, boolean exportAll) 

Source Link

Document

Create a new resolver for the given path.

Usage

From source file:com.gitblit.GitBlit.java

License:Apache License

/**
 * 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).//from ww w  . ja  v  a 2  s.com
 * 
 * @param settings
 */
public void configureContext(IStoredSettings settings, boolean startFederation) {
    logger.info("Reading configuration from " + settings.toString());
    this.settings = settings;
    repositoriesFolder = getRepositoriesFolder();
    logger.info("Git repositories folder " + repositoriesFolder.getAbsolutePath());
    repositoryResolver = new FileResolver<Void>(repositoriesFolder, true);

    // calculate repository list settings checksum for future config changes
    repositoryListSettingsChecksum.set(getRepositoryListSettingsChecksum());

    // build initial repository list
    if (settings.getBoolean(Keys.git.cacheRepositoryList, true)) {
        logger.info("Identifying available repositories...");
        getRepositoryList();
    }

    logTimezone("JVM", TimeZone.getDefault());
    logTimezone(Constants.NAME, getTimezone());

    serverStatus = new ServerStatus(isGO());
    String realm = settings.getString(Keys.realm.userService, "users.properties");
    IUserService loginService = null;
    try {
        // check to see if this "file" is a login service class
        Class<?> realmClass = Class.forName(realm);
        loginService = (IUserService) realmClass.newInstance();
    } catch (Throwable t) {
        loginService = new GitblitUserService();
    }
    setUserService(loginService);

    // load and cache the project metadata
    projectConfigs = new FileBasedConfig(getFileOrFolder(Keys.web.projectsFile, "projects.conf"), FS.detect());
    getProjectConfigs();

    mailExecutor = new MailExecutor(settings);
    if (mailExecutor.isReady()) {
        logger.info("Mail executor is scheduled to process the message queue every 2 minutes.");
        scheduledExecutor.scheduleAtFixedRate(mailExecutor, 1, 2, TimeUnit.MINUTES);
    } else {
        logger.warn("Mail server is not properly configured.  Mail services disabled.");
    }
    luceneExecutor = new LuceneExecutor(settings, repositoriesFolder);
    logger.info("Lucene executor is scheduled to process indexed branches every 2 minutes.");
    scheduledExecutor.scheduleAtFixedRate(luceneExecutor, 1, 2, TimeUnit.MINUTES);
    if (startFederation) {
        configureFederation();
    }

    // Configure JGit
    WindowCacheConfig cfg = new WindowCacheConfig();

    cfg.setPackedGitWindowSize(
            settings.getFilesize(Keys.git.packedGitWindowSize, cfg.getPackedGitWindowSize()));
    cfg.setPackedGitLimit(settings.getFilesize(Keys.git.packedGitLimit, cfg.getPackedGitLimit()));
    cfg.setDeltaBaseCacheLimit(
            settings.getFilesize(Keys.git.deltaBaseCacheLimit, cfg.getDeltaBaseCacheLimit()));
    cfg.setPackedGitOpenFiles(settings.getFilesize(Keys.git.packedGitOpenFiles, cfg.getPackedGitOpenFiles()));
    cfg.setStreamFileThreshold(
            settings.getFilesize(Keys.git.streamFileThreshold, cfg.getStreamFileThreshold()));
    cfg.setPackedGitMMAP(settings.getBoolean(Keys.git.packedGitMmap, cfg.isPackedGitMMAP()));

    try {
        WindowCache.reconfigure(cfg);
        logger.debug(MessageFormat.format("{0} = {1,number,0}", Keys.git.packedGitWindowSize,
                cfg.getPackedGitWindowSize()));
        logger.debug(
                MessageFormat.format("{0} = {1,number,0}", Keys.git.packedGitLimit, cfg.getPackedGitLimit()));
        logger.debug(MessageFormat.format("{0} = {1,number,0}", Keys.git.deltaBaseCacheLimit,
                cfg.getDeltaBaseCacheLimit()));
        logger.debug(MessageFormat.format("{0} = {1,number,0}", Keys.git.packedGitOpenFiles,
                cfg.getPackedGitOpenFiles()));
        logger.debug(MessageFormat.format("{0} = {1,number,0}", Keys.git.streamFileThreshold,
                cfg.getStreamFileThreshold()));
        logger.debug(MessageFormat.format("{0} = {1}", Keys.git.packedGitMmap, cfg.isPackedGitMMAP()));
    } catch (IllegalArgumentException e) {
        logger.error("Failed to configure JGit parameters!", e);
    }

    ContainerUtils.CVE_2007_0450.test();
}

---

From source file:com.google.gitiles.GitilesFilter.java

License:Open Source License

private void setDefaultFields(FilterConfig config) throws ServletException {
    if (renderer != null && urls != null && accessFactory != null && resolver != null
            && visibilityCache != null) {
        return;//from   ww  w .j a  v a  2  s.  com
    }
    String configPath = config.getInitParameter(CONFIG_PATH_PARAM);
    if (configPath == null) {
        throw new ServletException("Missing required parameter " + configPath);
    }
    FileBasedConfig jgitConfig = new FileBasedConfig(new File(configPath), FS.DETECTED);
    try {
        jgitConfig.load();
    } catch (IOException e) {
        throw new ServletException(e);
    } catch (ConfigInvalidException e) {
        throw new ServletException(e);
    }

    if (renderer == null) {
        String staticPrefix = config.getServletContext().getContextPath() + STATIC_PREFIX;
        String customTemplates = jgitConfig.getString("gitiles", null, "customTemplates");
        // TODO(dborowitz): Automatically set to true when run with mvn jetty:run.
        if (jgitConfig.getBoolean("gitiles", null, "reloadTemplates", false)) {
            renderer = new DebugRenderer(staticPrefix, customTemplates,
                    Joiner.on(File.separatorChar).join(System.getProperty("user.dir"), "gitiles-servlet", "src",
                            "main", "resources", "com", "google", "gitiles", "templates"));
        } else {
            renderer = new DefaultRenderer(staticPrefix, Renderer.toFileURL(customTemplates));
        }
    }
    if (urls == null) {
        try {
            urls = new DefaultUrls(jgitConfig.getString("gitiles", null, "canonicalHostName"),
                    getBaseGitUrl(jgitConfig), getGerritUrl(jgitConfig));
        } catch (UnknownHostException e) {
            throw new ServletException(e);
        }
    }
    linkifier = new Linkifier(urls);
    if (accessFactory == null || resolver == null) {
        String basePath = jgitConfig.getString("gitiles", null, "basePath");
        if (basePath == null) {
            throw new ServletException("gitiles.basePath not set");
        }
        boolean exportAll = jgitConfig.getBoolean("gitiles", null, "exportAll", false);

        FileResolver<HttpServletRequest> fileResolver;
        if (resolver == null) {
            fileResolver = new FileResolver<HttpServletRequest>(new File(basePath), exportAll);
            resolver = wrapResolver(fileResolver);
        } else if (resolver instanceof FileResolver) {
            fileResolver = (FileResolver<HttpServletRequest>) resolver;
        } else {
            fileResolver = null;
        }
        if (accessFactory == null) {
            checkState(fileResolver != null, "need a FileResolver when GitilesAccess.Factory not set");
            try {
                accessFactory = new DefaultAccess.Factory(new File(basePath), getBaseGitUrl(jgitConfig),
                        fileResolver);
            } catch (IOException e) {
                throw new ServletException(e);
            }
        }
    }
    if (visibilityCache == null) {
        if (jgitConfig.getSubsections("cache").contains("visibility")) {
            visibilityCache = new VisibilityCache(false, ConfigUtil.getCacheBuilder(jgitConfig, "visibility"));
        } else {
            visibilityCache = new VisibilityCache(false);
        }
    }
}

---

From source file:net.community.chest.gitcloud.facade.backend.git.BackendRepositoryResolver.java

License:Apache License

public BackendRepositoryResolver(File baseDir) {
    reposRoot = Validate.notNull(baseDir, "No base folder", ArrayUtils.EMPTY_OBJECT_ARRAY);
    if (reposRoot.exists()) {
        Assert.state(reposRoot.isDirectory(), "Non-folder root: " + reposRoot);
    } else {/*ww  w. j  av a  2s.c  o m*/
        Assert.state(reposRoot.mkdirs(), "Cannot create root folder: " + reposRoot);
    }

    resolver = new FileResolver<C>(reposRoot, true);
    logger.info("Base dir: " + ExtendedFileUtils.toString(reposRoot));

    synchronized (holder) {
        Assert.state(holder.get() == null, "Double registered resolver");
        holder.set(this);
    }
}

---